134
Part I: The C# Language
Here, class-name is the name of the class. Thus, a destructor is declared like a constructor 
except that it is preceded with a ~ (tilde). Notice it has no return type and takes no 
arguments.
To add a destructor to a class, you simply include it as a member. It is called whenever 
an object of its class is about to be recycled. Inside the destructor, you will specify those 
actions that must be performed before an object is destroyed.
It is important to understand that the destructor is called just prior to garbage collection. 
It is not called when a variable containing a reference to an object goes out of scope, for 
example. (This differs from destructors in C++, which are called when an object goes out 
of scope.) This means that you cannot know precisely when a destructor will be executed. 
Furthermore, it is possible for your program to end before garbage collection occurs, so a 
destructor might not get called at all.
The following program demonstrates a destructor. It works by creating and destroying 
a large number of objects. During this process, at some point the garbage collector will be 
activated, and the destructors for the objects will be called.
// Demonstrate a destructor.
using System;
class Destruct {
public int x;
public Destruct(int i) {
x = i;
}
// Called when object is recycled.
~Destruct() {
Console.WriteLine("Destructing " + x);
}
// Generates an object that is immediately destroyed.
public void Generator(int i) {
Destruct o = new Destruct(i);
}
}
class DestructDemo {
static void Main() {
int count;
Destruct ob = new Destruct(0);
/* Now, generate a large number of objects. At
some point, garbage collection will occur.
Note: You might need to increase the number
of objects generated in order to force
garbage collection. */
for(count=1; count < 100000; count++)
Pdf combine files online - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
add pdf files together; acrobat merge pdf files
Pdf combine files online - 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
add multiple pdf files into one online; acrobat reader merge pdf files
P
A
R
T
I
Chapter 6: Introducing Classes and Objects 
135
P
A
R
T
I
P
A
R
T
I
ob.Generator(count);
Console.WriteLine("Done");
}
}
Here is how the program works. The constructor sets the instance variable x to a known 
value. In this example, x is used as an object ID. The destructor displays the value of x when 
an object is recycled. Of special interest is Generator( ). This method creates and then promptly 
destroys a Destruct object. The DestructDemo class creates an initial Destruct object called 
ob. Then using ob, it creates 100,000 objects by calling Generator( ) on ob. This has the net 
effect of creating and destroying 100,000 objects. At various points in the middle of this 
process, garbage collection will take place. Precisely how often or when is dependent upon 
several factors, such as the initial amount of free memory, the operating system, and so on. 
Howeveructor. If 
you don’t see the messages prior to program termination (that is, before you see the “Done” 
message), try increasing the number of objects being generated by upping the count in the 
for loop.
One important point: The call to WriteLine( ) inside ~Destruct( ) is purely for the sake of 
illustration in this rather contrived example. Normally, a destructor should act only on the 
instance variables defined by its class.
Because of the nondeterministic way in which destructors are called, they should not 
ogram. One other 
point: It is possible to r
library is discussed. However, manually initiating garbage collection is not recommended 
for most circumstances, because it can lead to inefficiencies. Also, because of the way the 
garbage collector works, even if you explicitly request garbage collection, there is no way 
to know precisely when a specific object will be recycled.
The this Keyword
Before concluding this chapter, it is necessary to introduce this. When a method is called, 
it is automatically passed a reference to the invoking object (that is, the object on which the 
method is called). This reference is called this. Therefore, this refers to the object on which 
the method is acting. To understand this, first consider a program that creates a class called 
Rect that encapsulates the width and height of a rectangle and that includes a method 
calledArea( ) that returns its area.
using System;
class Rect {
public int Width;
public int Height;
public Rect(int w, int h) {
Width = w;
Height = h;
}
public int Area() {
Online Merge PDF files. Best free online merge PDF tool.
Drag and drop your PDF or several files in the box Also you can add more PDFs to combine them and merge to make it as easy as possible to merge your PDF files.
append pdf; pdf combine files online
C# Word - Merge Word Documents in C#.NET
RasterEdge C#.NET Word document merging toolkit (XDoc.Word) is designed to help .NET developers combine Word document files created by different users to one
pdf merger; best pdf combiner
136
Part I: The C# Language
return Width * Height;
}
}
class UseRect {
static void Main() {
Rect r1 = new Rect(4, 5);
Rect r2 = new Rect(7, 9);
Console.WriteLine("Area of r1: " + r1.Area());
Console.WriteLine("Area of r2: " + r2.Area());
}
}
As you know, within a method, the other members of a class can be accessed directly, 
without any object or class qualification. Thus, inside Area( ), the statement
return Width * Height;
means that the copies of Width and Height associated with the invoking object will be 
multiplied together and the result returned. However, the same statement can also be 
written like this:
return this.Width * this.Height;
Here, this refers to the object on which Area( ) was called. Thus, this.Width refers to that 
object’s copy of Width, and this.Height refers to that object’s copy of Height. For example, 
ifArea( ) had been invoked on an object called x, then this in the preceding statement 
would have been referring to x. Writing the statement without using this is really just 
shorthand.
It is also possible to use this inside a constructor. In this case, this refers to the object 
that is being constructed. For example, inside Rect( ), the statements
Width = w;
Height = h;
can be written like this:
this.Width = w;
this.Height = h;
Of course, there is no benefit in doing so in this case.
For the sake of illustration, here is the entire Rect class written using the this reference:
using System;
class Rect {
public int Width;
public int Height;
public Rect(int w, int h) {
C# PowerPoint - Merge PowerPoint Documents in C#.NET
RasterEdge C#.NET PowerPoint document merging toolkit (XDoc.PowerPoint) is designed to help .NET developers combine PowerPoint document files created by
c# merge pdf files; how to combine pdf files
C# PDF: C#.NET PDF Document Merging & Splitting Control SDK
SDK > C# > Merge and Split Document(s). "This online guide content is toolkit is designed to help .NET developers combine PDF document files created by
acrobat combine pdf; c# merge pdf pages
P
A
R
T
I
Chapter 6: Introducing Classes and Objects 
137
P
A
R
T
I
P
A
R
T
I
this.Width = w;
this.Height = h;
}
public int Area() {
return this.Width * this.Height;
}
}
class UseRect {
static void Main() {
Rect r1 = new Rect(4, 5);
Rect r2 = new Rect(7, 9);
Console.WriteLine("Area of r1: " + r1.Area());
Console.WriteLine("Area of r2: " + r2.Area());
}
}
Actually, no C# programmer would use this as just shown because nothing is gained 
and the standard form is easier. However, this has some important uses. For example, the 
an instance variable. When this happens, the local name hides the instance variable. You can 
gain access to the hidden instance variable by referring to it through this. For example, the 
following is a syntactically valid way to write the Rect( ) constructor:
public Rect(int Width, int Height) {
this.Width = Width;
this.Height = Height;
}
In this version, the names of the parameters are the same as the names of the instance 
variables, thus hiding them. However, this is used to “uncover” the instance variables.
C# PDF File Split Library: Split, seperate PDF into multiple files
Also able to combine generated split PDF document files with other PDF files to form Advanced component for splitting PDF document in preview without
pdf combine; add two pdf files together
VB.NET Word: Merge Multiple Word Files & Split Word Document
destnPath As [String]) DOCXDocument.Combine(docList, destnPath Merge Word Files or Split Word in Batch Mode. & profession imaging controls, PDF document, image
scan multiple pages into one pdf; asp.net merge pdf files
This page intentionally left blank 
VB.NET TIFF: Merge and Split TIFF Documents with RasterEdge .NET
docList As [String]()) TIFFDocument.Combine(filePath, docList be processed and manipulated TIFF files in high & profession imaging controls, PDF document, tiff
best pdf merger; build pdf from multiple files
VB.NET PowerPoint: Merge and Split PowerPoint Document(s) with PPT
Just like we need to combine PPT files, sometimes, we also be divided into two separate sub-PPT files from the If you want to see more PDF processing functions
acrobat merge pdf; break pdf into multiple files
7
Arrays and Strings
T
his chapter r
string
type. The foreach loop is also examined.
Arrays
Anarray is a collection of variables of the same type that are referred to by a common name. 
In C#, arrays can have one or more dimensions, although the one-dimensional array is the 
most common. Arrays are used for a variety of purposes because they offer a convenient 
means of grouping together related variables. For example, you might use an array to hold 
a record of the daily high temperature for a month, a list of stock prices, or your collection 
of programming books.
The principal advantage of an array is that it organizes data in such a way that it can 
selected group of stocks, it is easy to compute the average income by cycling through the 
array. Also, arrays organize data in such a way that it can be easily sorted.
Although arrays in C# can be used just like arrays in many other programming languages, 
they have one special attribute: They are implemented as objects. This fact is one reason that 
a discussion of arrays was deferred until objects had been introduced. By implementing 
arrays as objects, several important advantages are gained, not the least of which is that 
unused arrays can be garbage-collected.
One-Dimensional Arrays
Aone-dimensional array is a list of related variables. Such lists are common in programming. 
For example, you might use a one-dimensional array to store the account numbers of the 
active users on a network. Another array might store the current batting averages for a 
baseball team.
Because arrays in C# are implemented as objects, two steps are needed to obtain an 
array for use in your program. First, you must declare a variable that can refer to an array. 
Second, you must create an instance of the array by use of new. Therefore, to declare a one-
dimensional array, you will typically use this general form:
type[ ] array-name = new type[size];
139
CHAPTER
140
Part I: The C# Language
Here, type declares the elementtype of the array. The element type determines the data type 
of each element that comprises the array. Notice the square brackets that follow type. They 
indicate that a one-dimensional array is being declared. The number of elements that the 
array will hold is determined by size.
N
OTE
N
OTE
If you come from a C or C++ background, pay special attention to the way arrays are 
declared. Specifically, the square brackets follow the type name, not the array name.
Here is an example. The following creates an int array of ten elements and links it to an 
array reference variable named sample.
int[] sample = new int[10];
Thesample variable holds a reference to the memory allocated by new. This memory is 
large enough to hold ten elements of type int.
As is the case when creating an instance of a class, it is possible to break the preceding 
declaration in two. For example:
int[] sample;
sample = new int[10];
In this case, when sample is first created, it refers to no physical object. It is only after the 
second statement executes that sample refers to an array.
An individual element within an array is accessed by use of an index. An index describes 
the position of an element within an array. In C#, all arrays have 0 as the index of their first 
element. Because sample has 10 elements, it has index values of 0 through 9. To index an 
array, specify the number of the element you want, surrounded by square brackets. Thus, 
the first element in sample is sample[0], and the last element is sample[9]. For example, the 
following program loads sample with the numbers 0 through 9:
// Demonstrate a one-dimensional array.
using System;
class ArrayDemo {
static void Main() {
int[] sample = new int[10];
int i;
for(i = 0; i < 10; i = i+1)
sample[i] = i;
for(i = 0; i < 10; i = i+1)
Console.WriteLine("sample[" + i + "]: " + sample[i]);
}
}
The output from the program is shown here:
sample[0]: 0
sample[1]: 1
sample[2]: 2
P
A
R
T
I
Chapter 7: Arrays and Strings 
141
P
A
R
T
I
P
A
R
T
I
sample[3]: 3
sample[4]: 4
sample[5]: 5
sample[6]: 6
sample[7]: 7
sample[8]: 8
sample[9]: 9
Conceptually, the sample array looks like this:
Arrays are common in programming because they let you deal easily with large numbers 
of related variables. For example, the following program finds the average of the set of values 
stored in the nums array by cycling through the array using a for loop:
// Compute the average of a set of values.
using System;
class Average {
static void Main() {
int[] nums = new int[10];
int avg = 0;
nums[0] = 99;
nums[1] = 10;
nums[2] = 100;
nums[3] = 18;
nums[4] = 78;
nums[5] = 23;
nums[6] = 63;
nums[7] = 9;
nums[8] = 87;
nums[9] = 49;
for(int i=0; i < 10; i++)
avg = avg + nums[i];
avg = avg / 10;
Console.WriteLine("Average: " + avg);
}
}
The output from the program is shown here:
Average: 53
142
Part I: The C# Language
Initializing an Array
In the preceding program, the nums array was given values by hand, using ten separate 
assignment statements. While that is perfectly correct, there is an easier way to accomplish 
this. Arrays can be initialized when they are created. The general form for initializing a one-
dimensional array is shown here:
type[ ] array-name = { val1,val2,val3, ..., valN };
Here, the initial values are specified by val1 through valN. They are assigned in sequence, 
left to right, in index order. C# automatically allocates an array large enough to hold the 
initializers that you specify. There is no need to use the new operator explicitly. For example, 
here is a better way to write the Average program:
// Compute the average of a set of values.
using System;
class Average {
static void Main() {
int[] nums = { 99, 10, 100, 18, 78, 23,
63, 9, 87, 49 };
int avg = 0;
for(int i=0; i < 10; i++)
avg = avg + nums[i];
avg = avg / 10;
Console.WriteLine("Average: " + avg);
}
}
As a point of interest, although not needed, you can use new when initializing an array. 
For example, this is a proper, but redundant, way to initialize nums in the foregoing 
program:
int[] nums = new int[] { 99, 10, 100, 18, 78, 23,
63, 9, 87, 49 };
Although redundant here, the new form of array initialization is useful when you are 
assigning a new array to an already-existent array reference variable. For example:
int[] nums;
nums = new int[] { 99, 10, 100, 18, 78, 23,
63, 9, 87, 49 };
In this case, nums is declared in the first statement and initialized by the second.
array, but the size must agree with the number of initializers. For example, here is another 
way to initialize nums:
int[] nums = new int[10] { 99, 10, 100, 18, 78, 23,
63, 9, 87, 49 };
In this declaration, the size of nums is explicitly stated as 10.
P
A
R
T
I
Chapter 7: Arrays and Strings 
143
P
A
R
T
I
P
A
R
T
I
Boundaries Are Enforced
Array boundaries are strictly enforced in C#; it is a runtime error to overrun or underrun 
the ends of an array. If you want to confirm this for yourself, try the following program that 
purposely overruns an array:
// Demonstrate an array overrun.
using System;
class ArrayErr {
static void Main() {
int[] sample = new int[10];
int i;
// Generate an array overrun.
for(i = 0; i < 100; i = i+1)
sample[i] = i;
}
}
As soon as i reaches 10, an IndexOutOfRangeException is generated and the program is 
Multidimensional Arrays
Although the one-dimensional array is the most commonly used array in programming, 
multidimensional arrays are certainly not rare. A multidimensional array is an array that has 
two or more dimensions, and an individual element is accessed through the combination 
of two or more indices.
Two-Dimensional Arrays
. In a two-
dimensional array
ow, the 
other indicates the column.
To declare a two-dimensional integer array table of size 10, 20, you would write
int[,] table = new int[10, 20];
Pay careful attention to the declaration. Notice that the two dimensions are separated from 
each other by a comma. In the first part of the declaration, the syntax
[,]
indicates that a two-dimensional array reference variable is being created. When memory is 
actually allocated for the array using new, this syntax is used:
int[10, 20]
This creates a 10×20 array, and again, the comma separates the dimensions.
Documents you may be interested
Documents you may be interested