624
Part I: The C# Language
class Test {
static void Main() {
XY xy = new XY(1, 2);
Console.WriteLine(xy.X + "," + xy.Y);
}
}
To use XY, all files must be included in the compile. For example, assuming the XY files 
are called xy1.cs, xy2.cs, and xy3.cs, and that the Test class is contained in a file called test.cs,
then to compile Test, use the following command line:
csc test.cs xy1.cs xy2.cs xy3.cs
One last point: It is legal to have partial generic classes. However, the type parameters 
of each partial declaration must match the other parts.
Partial Methods
As the preceding section described, you can use partial to create a partial type. Beginning 
with C# 3.0, there is a second use of partial that lets you create a partialmethod within a 
partial type. A
another part. Thus, in a partial class or structure, partial can be used to allow the declaration 
of a method to be separate from its implementation.
The key aspect of a partial method is that the implementation is not required! When the 
partial method is not implemented by another part of the class or structure, then all calls to 
the partial method are silently ignored. This makes it possible for a class to specify, but not 
require, optional functionality. If that functionality is not implemented, then it is simply 
ignored.
Here is an expanded version of the preceding program that creates a partial method 
calledShow( ). It is called by another method called ShowXY( ). (For convenience, all pieces 
of the partial class XY are shown in one file, but they could have been organized into 
separate files, as illustrated in the preceding section.)
// Demonstrate a partial method.
using System;
partial class XY {
public XY(int a, int b) {
X = a;
Y = b;
}
// Declare a partial method.
partial void Show();
}
partial class XY {
public int X { get; set; }
Pdf mail merge - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
best pdf merger; c# merge pdf files
Pdf mail merge - 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
c# merge pdf files into one; pdf merge documents
P
A
R
T
I
Chapter 20: Unsafe Code, Pointers, Nullable Types, Dynamic Types, and Miscellaneous Topics
625
P
A
R
T
I
P
A
R
T
I
// Implement a partial method.
partial void Show() {
Console.WriteLine("{0}, {1}", X, Y);
}
}
partial class XY {
public int Y { get; set; }
// Call a partial method.
public void ShowXY() {
Show();
}
}
class Test {
static void Main() {
XY xy = new XY(1, 2);
xy.ShowXY();
}
}
Notice that Show( ) is declared in one part of XY and implemented by another part. 
The implementation displays the values of X and Y. This means that when Show( ) is called 
byShowXY( ), the call has effect, and it will, indeed, display X and Y. However, if you 
comment-out the implementation of Show( ), then the call to Show( ) within ShowXY( )
does nothing.
Partial methods have several restrictions, including these: They must return void. They 
cannot have access modifiers. They cannot be virtual. They cannot use out parameters.
Create a Dynamic Type with dynamic
As first mentioned in Chapter 3, C# is a strongly typed language. In general, this means that 
all operations ar
compiled. Although strong typing is a great benefit to the programmer, helping ensure 
resilient, reliable programs, it can be problematic in situations in which the type of an object 
is not known until runtime. This situation might be encountered when using reflection, 
accessing a COM object, or when needing interoperability with a dynamic language, such 
as IronPython, for example. Prior to C# 4.0, these situations could be difficult to handle. To 
address this problem, C# 4.0 added a new data type called dynamic.
With an important exception, the dynamic type is similar to object because it can be 
used to refer to any type of object. The difference between object and dynamic is that all 
type checking related to a dynamic type is deferred until runtime. (With object, type 
checking still occurs at compile time.) The benefit of waiting until runtime is that, at compile 
time, a dynamic
or. 
Of course, if at r
runtime exception will occur.
C# Word - MailMerge Processing in C#.NET
Mail Merge Processing. |. Home ›› XDoc.Word ›› C# Word: Process Mail Merge. IDocument doc = document0.GetDocument().Clone(); // Execute mail merge.
acrobat combine pdf files; batch pdf merger
C# Word - Merge Word Documents in C#.NET
C# Word - Merge Word Documents in C#.NET. Provide C# Demo Codes for Merging and Appending Word Document. Combine and Merge Multiple Word Files into One Using C#.
build pdf from multiple files; c# combine pdf
626
Part I: The C# Language
The following program shows dynamic in action:
// Demonstrate the use of dynamic.
using System;
using System.Globalization;
class DynDemo {
static void Main() {
// Declare two dynamic variables.
dynamic str;
dynamic val;
// Implicit conversion to dynamic types is supported.
// Therefore the following assignments are legal.
str = "This is a string";
val = 10;
Console.WriteLine("str contains " + str);
Console.WriteLine("val contains " + val + '\n');
str = str.ToUpper(CultureInfo.CurrentCulture);
Console.WriteLine("str now contains " + str);
val = val + 2;
Console.WriteLine("val now contains " + val + '\n');
string str2 = str.ToLower(CultureInfo.CurrentCulture);
Console.WriteLine("str2 contains " + str2);
// Implicit conversions from dynamic types are supported.
int x = val * 2;
Console.WriteLine("x contains " + x);
}
}
The output from the program is shown here:
str contains This is a string
val contains 10
str now contains THIS IS A STRING
val now contains 12
str2 contains this is a string
x contains 24
In the program, notice how the two variables, str and val, are declared using the dynamic
at compile time. As a result, any operation can be applied to them. In this case, str calls the 
String methods, ToUpper( ) and ToLower( ), and val uses the addition and multiplication 
How to C#: Overview of Using XDoc.Word
Tell C# users how to: create a new Word file and load Word from pdf; merge, append, and split Word files; insert, delete, move, rotate, copy and paste Word
append pdf files reader; c# merge pdf pages
How to C#: Convert PDF, Excel, PPT to Word
Images. Convert Word to ODT. Convert PDF to Word. Convert ODT to Word. Document Delete Word Pages. Page: Move Word Page Position. Page: Extract Word Pages. Mail
add pdf files together online; add two pdf files together
P
A
R
T
I
Chapter 20: Unsafe Code, Pointers, Nullable Types, Dynamic Types, and Miscellaneous Topics
627
P
A
R
T
I
P
A
R
T
I
operators. Although these actions are compatible with the types of objects assigned to the 
without question. This, of course, simplifies the coding of dynamic routines, but allows the 
possibility that such actions will produce a runtime error.
In this example, the program behaves correctly at runtime because the objects assigned to 
these references support the actions used in the program. Specifically, because val is assigned 
an integer value, integer operations such as addition are supported. Because str is assigned a 
string, string operations are supported. Understand, however, that it is your responsibility to 
ensure that all operations applied to a dynamic type are actually supported by the type of 
object being referred to. If they aren’t, a program crash will occur.
One other thing to notice in the preceding example: any type of object reference can be 
assigned to a dynamic variable. This is because an implicit conversion is provided from any 
type to dynamic. Also, a dynamic type is automatically converted to any other type. Of 
course, if at runtime such a conversion is invalid, then a runtime error will result. For 
example, if you add this line to the end of the preceding example,
bool b = val;
a runtime error will result because there is no implicit conversion defined from int (which 
is the runtime type of val in this case) to bool. Therefore, even though this line will compile 
without error, it will result in a runtime error.
Before leaving this example, try a short experiment. Change the type of str and val to 
object, and then try recompiling. As you will see, compile-time errors result. This is because 
object does not support the actions that are performed on the variables, and this is caught 
during compilation. This is the primary difference between object and dynamic. Even though 
both can be used to refer to any other type of object, only those actions supported by object
can be used on a variable of type object. By using dynamic, you can specify whatever action 
eferred to at runtime.
To see how dynamic can simplify certain tasks, we will work through a simple example 
that uses it with reflection. As explained in Chapter 17, one way to invoke a method on an 
object of a class that was obtained at runtime via reflection is to call the Invoke( ) method. 
Although this works, it would be more convenient to invoke that method by name in cases 
in which the method name is known. For example, you might have a situation in which you 
and actions are known. However, because this assembly is subject to change, you always 
want to make sure that you are using the latest version. One way to accomplish this is to 
use reflection to examine the assembly, construct an object of the class, and then invoke the 
methods defined by the class. By using dynamic, you can now invoke those methods by 
name (since the names are known) rather than through the Invoke( ) method.
To begin, put the following code in a file called MyClass.cs. This is the code that will 
be dynamically loaded via reflection.
public class DivBy {
public bool IsDivBy(int a, int b) {
if((a % b) == 0) return true;
return false;
}
C# Word - Convert Word to PDF in C#.NET
Word: Convert Word to PDF. C# Word - Convert Word to PDF in C#.NET. Online C# Tutorial for Converting Word to PDF (.pdf) Document. Word to PDF Conversion Overview
add pdf together one file; pdf combine pages
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
Password protected PDF file can be printed to Word for mail merge. C# source code is available for copying and using in .NET Class.
acrobat split pdf into multiple files; batch merge pdf
628
Part I: The C# Language
public bool IsEven(int a) {
if((a % 2) == 0) return true;
return false;
}
}
Next, compile this file into a DLL called MyClass.dll. If you are using the command-line 
compiler, then you can use this line:
csc /t:library MyClass.cs
Now, create the following program that uses MyClass.dll, as shown here:
// Use dynamic with reflection.
using System;
using System.Reflection;
class DynRefDemo {
static void Main() {
Assembly asm = Assembly.LoadFrom("MyClass.dll");
Type[] all = asm.GetTypes();
// Find the DivBy class.
int i;
for(i = 0; i < all.Length; i++)
if(all[i].Name == "DivBy") break;
if(i == all.Length) {
Console.WriteLine("DivBy not found in assembly.");
return;
}
Type t = all[i];
// Now, find the default constructor.
ConstructorInfo[] ci = t.GetConstructors();
int j;
for(j = 0; j < ci.Length; j++)
if(ci[j].GetParameters().Length == 0) break;
if(j == ci.Length) {
Console.WriteLine(“Default constructor not found.”);
return;
}
// Create a DivBy object dynamically.
dynamic obj = ci[j].Invoke(null);
// Now, invoke methods on obj by name. This is legal because
// obj is of type dynamic, and the calls to the methods are
XDoc.Word for .NET, Advanced .NET Word Processing Features
mail-merge in OpenXML file, Microsoft access database and field; More about Word Mail-Merge ▶. Extract raw image or clipped and scaled image from PDF file.
.net merge pdf files; attach pdf to mail merge
C# Word - Process Word Document in C#
Word document processing implementations using C# demo codes, such as add or delete Word document page, change Word document pages order, merge or split Word
add pdf pages together; acrobat merge pdf
P
A
R
T
I
Chapter 20: Unsafe Code, Pointers, Nullable Types, Dynamic Types, and Miscellaneous Topics
629
P
A
R
T
I
P
A
R
T
I
// type-checked at runtime, not compile time.
if(obj.IsDivBy(15, 3))
Console.WriteLine("15 is evenly divisible by 3.");
else
Console.WriteLine("15 is NOT evenly divisible by 3.");
if(obj.IsEven(9))
Console.WriteLine("9 is even.");
else
Console.WriteLine("9 is NOT even.");
}
}
As you can see, the program dynamically loads MyClass.dll and then uses reflection 
to construct a DivBy object. The object constructed is assigned to obj, which is of type 
dynamic. Because it is dynamic, the methods IsDivBy( ) and IsEven( ) can be called on obj
by name, rather than through the Invoke( ) method. This works, of course, because in this 
example,obj does, in fact, refer to a DivBy object. If it did not, the program would fail.
Although the preceding example is, obviously, contrived and simplified, it does 
illustrate in principle the benefit the dynamic type brings to situations in which types are 
obtained at r
operators, fields, and properties, you can use the characteristics by name, through a dynamic
type, as in the preceding example. Doing so can make your code cleaner, shorter, and easier 
to understand.
There is another thing to keep in mind when using dynamic. When a program is compiled, 
dynamic is actually replaced with object and runtime information is included to describe 
the usage. Because dynamic is compiled into type object, for the purposes of overloading, 
dynamic and object are seen as the same. Therefore, the following two overloaded methods 
will generate a compile-time error:
static void f(object v) { // ... }
static void f(dynamic v) { // ... } // Error!
One last point: dynamic is supported by the Dynamic Language Runtime (DLR), which 
was added by .NET 4.0.
COM Interoperability
C# 4.0 adds features that streamline the ability to interact with unmanaged code that is 
fice Automation. 
Some of these features, such as the dynamic type, and named and optional properties, are 
applicable beyond COM interoperability. COM in general, and Office Automation in 
particular, is a very lar
discuss it. Therefore, the topic of COM interoperability is also outside the scope of this book.
The preceding notwithstanding, two features related to COM interoperability warrant a 
brief mention. The first is the use of indexed properties. The second is the ability to pass value
arguments to COM methods that require a reference.
As you know, a C# property is normally associated with only one value, with a single 
get and set accessor. However, this is not the case with all COM properties. To address this 
VB.NET Image: Barcode Reader SDK, Read Intelligent Mail from Image
VB.NET Demo Code to Decode Intelligent Mail on PDF Page. With the help of well developed image barcode reading API methods and following demo code in VB program
pdf split and merge; apple merge pdf
How to C#: Quick to Start Using XDoc.Word
To meet your requirement, on this quick to start page, we will tell how to create a C# console application, merge two Word files, and save into a new Word file
acrobat reader merge pdf files; pdf merge files
630
Part I: The C# Language
indexed
property to access a COM property that has more than one parameter. This is done by 
indexing the property name, much as though it were an indexer. For example, assuming an 
object called myXLApp that is an object of type Microsoft.Office.Interop.Execl.Application,
in the past, to set cells C1 through C3 with the string “OK” in an Excel spreadsheet, you 
could use a statement like this:
myXLapp.get_Range("C1", "C3").set_Value(Type.Missing, "OK");
Here, the range is obtained by calling get_Range( ), specifying the beginning and ending of 
the range. The values are set by calling set_Value( ), specifying the type (which is optional) and 
the value. These methods use the Range and Value properties. The reason methods are used 
is that both of these properties have two parameters. Thus, in the past, you could not refer to 
them as properties, but needed to use the methods shown. Also, the Type.Missing argument 
beginning with C# 4.0, the preceding statement can be written more conveniently as
myXLapp.Range["C1", "C3"].Value = "OK";
In this case, the range values are passed using the indexer syntax, and the Type.Missing
placeholder is not needed because this parameter now defaults.
Normally, when a method defines a ref parameter, you must pass a reference to that 
parameter. However, when working with COM, you can pass a value to a ref parameter 
create a temporary argument for you that is already wrapped in an object, and ref is not 
needed in the argument list.
Friend Assemblies
It is possible to make one assembly the friend of another. A friend has access to the internal
members of the assembly of which it is a friend. This feature makes it possible to share members 
between selected assemblies without making those members public. To declare a friend 
assembly, you must use the InternalsVisibleTo attribute.
Miscellaneous Keywords
To conclude Part I, the few remaining keywords defined by C# that have not been described 
elsewhere are briefly discussed.
lock
Thelock keyword is used when creating multithreaded programs. It is examined in detail 
in Chapter 23, where multithreaded programming is discussed. A brief description is given 
here for the sake of completeness.
In C#, a program can contain more than one thread of execution. When this is the case, the 
program is said to be multithreaded, and pieces of the program are executed concurrently. Thus, 
pieces of the program execute independently and simultaneously. This raises the prospect 
of a special type of problem: What if two threads try to use a resource that can be used by 
P
A
R
T
I
Chapter 20: Unsafe Code, Pointers, Nullable Types, Dynamic Types, and Miscellaneous Topics
631
P
A
R
T
I
P
A
R
T
I
only one thread at a time? To solve this problem, you can create a critical code section that 
will be executed by one and only one thread at a time. This is accomplished by lock. Its 
general form is shown here:
lock(obj) {
// critical section
}
Here, obj is the object on which the lock is synchronized. If one thread has already entered 
the critical section, then a second thread will wait until the first thread exits the critical 
section. When the first thread leaves the critical section, the lock is released and the second 
thread can be granted the lock, at which point the second thread can execute the critical 
section.
N
OTE
N
OTE
lock is discussed in detail in Chapter 23.
readonly
You can create a read-only field in a class by declaring it as readonly. A readonly field can 
be given a value only by using an initializer when it is declared or by assigning it a value 
within a constructor. Once the value has been set, it can’t be changed outside the constructor. 
Thus, a readonly field is a good way to create a fixed value that has its value set by a 
constructor. For example, you might use a readonly field to represent an array dimension 
that is used frequently throughout a program. Both static and non-static readonly fields are 
allowed.
N
OTE
N
OTE
Although similar, readonly fields are not the same as const fields, which are described in the 
following section.
Here is an example that creates a readonly field:
// Demonstrate readonly.
using System;
class MyClass {
public static readonly int SIZE = 10;
}
class DemoReadOnly {
static void Main() {
int[] source = new int[MyClass.SIZE];
int[] target = new int[MyClass.SIZE];
// Give source some values.
for(int i=0; i < MyClass.SIZE; i++)
source[i] = i;
foreach(int i in source)
Console.Write(i + " ");
Console.WriteLine();
632
Part I: The C# Language
// Reverse copy source into target.
for(int i = MyClass.SIZE-1, j = 0; i > 0; i--, j++)
target[j] = source[i];
foreach(int i in target)
Console.Write(i + " ");
Console.WriteLine();
//  MyClass.SIZE = 100; // Error!!! can’t change
}
}
Here, MyClass.SIZE is initialized to 10. After that, it can be used, but not changed. To prove 
this, try removing the comment symbol from before the last line and then compiling the 
program. As you will see, an error will result.
const and volatile
Theconst modifier is used to declare fields or local variables that cannot be changed. These 
variables must be given initial values when they are declared. Thus, a const variable is 
essentially a constant. For example,
const int i = 10;
creates a const variable called i that has the value 10. Although a const field is similar to a 
readonly field, the two are not the same. A const field cannot be set within a constructor, 
but a readonly field can.
Thevolatile
more concurrently executing threads. In this situation, one thread may not know when the 
field has been changed by another thread. This is important because the C# compiler will 
single thread of execution. To prevent these optimizations from being applied to a shared 
field, declare it volatile
time it is accessed.
The using Statement
In addition to the usingdirective discussed earlier in this book, using has a second form that 
is called the usingstatement. It has these general forms:
using (obj) {
// use obj
}
using (typeobj = initializer) {
// use obj
}
Here, obj is an expression that must evaluate to an object that implements the 
System.IDisposable interface. It specifies a variable that will be used inside the using
P
A
R
T
I
Chapter 20: Unsafe Code, Pointers, Nullable Types, Dynamic Types, and Miscellaneous Topics
633
P
A
R
T
I
P
A
R
T
I
block. In the first form, the object is declared outside the using statement. In the second 
form, the object is declared within the using statement. When the block concludes, the 
Dispose( ) method (defined by the System.IDisposable interface) will be called on obj.
Dispose( ) is called even if the using block ends because of an exception. Thus, a using
statement provides a means by which objects are automatically disposed when they are no 
longer needed. Remember, the using statement applies only to objects that implement the 
System.IDisposableinterface.
Here is an example of each form of the using statement:
// Demonstrate using statement.
using System;
using System.IO;
class UsingDemo {
static void Main() {
try {
StreamReader sr = new StreamReader("test.txt");
// Use object inside using statement.
using(sr) {
// ...
}
} catch(IOException exc) {
// ...
}
try {
// Create a StreamReader inside the using statement.
using(StreamReader sr2 = new StreamReader("test.txt")) {
// ...
}
} catch(IOException exc) {
// ...
}
}
}
The class StreamReader implements the IDisposable interface (through its base class 
TextReader). Thus, it can be used in a using statement. When the using statement ends, 
Dispose( ) is automatically called on the stream variable, thus closing the stream.
As the preceding example illustrates, using is particularly useful when working with 
files because the file is automatically closed at the end of the using block, even if the block 
ends because of an exception. As a result, closing a file via using often simplifies file-handling 
code. Of course, using is not limited to just files. There are many other resources in the .NET 
Framework that implement IDisposable. All can be managed via using.
extern
Theextern keyword has two uses. Each is examined here.
Documents you may be interested
Documents you may be interested