asp net core 2.0 mvc pdf : Merge pdf SDK application service wpf html windows dnn McGraw.Hill.CSharp.4.0.The.Complete.Reference.Apr.201019-part1175

164
Part I: The C# Language
// Display the digits of an integer using words.
using System;
class ConvertDigitsToWords {
static void Main() {
int num;
int nextdigit;
int numdigits;
int[] n = new int[20];
string[] digits = { "zero", "one", "two",
"three", "four", "five",
"six", "seven", "eight",
"nine" };
num = 1908;
Console.WriteLine("Number: " + num);
Console.Write("Number in words: ");
nextdigit = 0;
numdigits = 0;
// Get individual digits and store in n.
// These digits are stored in reverse order.
do {
nextdigit = num % 10;
n[numdigits] = nextdigit;
numdigits++;
num = num / 10;
} while(num > 0);
numdigits--;
// Display the words.
for( ; numdigits >= 0; numdigits--)
Console.Write(digits[n[numdigits]] + " ");
Console.WriteLine();
}
}
The output is shown here:
Number: 1908
Number in words: one nine zero eight
In the program, the string array digits holds in order the word equivalents of the digits 
from zero to nine. The program converts an integer into words by first obtaining each digit 
of the value and storing those digits, in reverse order, in the int array called n. Then, this 
array is cycled through from back to front. In the process, each integer value in n is used as 
an index into digits, with the corresponding string being displayed.
Merge pdf - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
attach pdf to mail merge in word; add pdf together
Merge pdf - 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; append pdf files reader
P
A
R
T
I
Chapter 7: Arrays and Strings 
165
P
A
R
T
I
P
A
R
T
I
Strings Are Immutable
Here is something that might surprise you: The contents of a string object are immutable. 
That is, once created, the character sequence comprising that string cannot be altered. This 
restriction allows strings to be implemented more efficiently. Even though this probably 
that already exists, simply create a new string that contains the desired changes. Because 
unused string objects are automatically garbage-collected, you don’t even need to worry 
about what happens to the discarded strings.
It must be made clear, however, that string reference variables may, of course, change 
which object they refer to. It is just that the contents of a specific string object cannot be 
changed after it is created.
To fully understand why immutable strings are not a hindrance, we will use another of 
string’s methods: Substring( ). The Substring( ) method returns a new string that contains 
a specified portion of the invoking string. Because a new string object is manufactured that 
contains the substring, the original string is unaltered, and the rule of immutability is still 
intact. The form of Substring( ) that we will be using is shown here:
string Substring(int startIndex, int length)
Here, startIndex specifies the beginning index, and length specifies the length of the substring.
Here is a program that demonstrates Substring( ) and the principle of immutable 
strings:
// Use Substring().
using System;
class SubStr {
static void Main() {
string orgstr = "C# makes strings easy.";
// Construct a substring.
string substr = orgstr.Substring(5, 12);
Console.WriteLine("orgstr: " + orgstr);
Console.WriteLine("substr: " + substr);
}
}
Here is the output from the program:
orgstr: C# makes strings easy.
substr: kes strings
As you can see, the original string orgstr is unchanged, and substr contains the substring.
One more point: Although the immutability of string objects is not usually a restriction 
or hindrance, ther
To allow this, C# offers a class called StringBuilder, which is in the System.Text namespace.
It creates string objects that can be changed. For most purposes, however, you will want to 
usestring, not StringBuilder.
Online Merge PDF files. Best free online merge PDF tool.
Online Merge PDF, Multiple PDF files into one. Download Free Trial. Merge PDF, Multiple PDF files. Drag and drop your PDF or several files in the box above.
append pdf; batch pdf merger
C# WPF PDF Viewer SDK to view, annotate, convert and print PDF in
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
break pdf into multiple files; how to combine pdf files
166
Part I: The C# Language
Strings Can Be Used in switch Statements
Astring can be used to control a switch statement. It is the only non-integer type that can 
be used in the switch. The fact that strings can be used in switch statements makes it 
possible to handle some otherwise difficult situations quite easily. For example, the 
following program displays the digit equivalent of the words “one,” “two,” and “three”:
// A string can control a switch statement.
using System;
class StringSwitch {
static void Main() {
string[] strs = { "one", "two", "three", "two", "one" };
foreach(string s in strs) {
switch(s) {
case "one":
Console.Write(1);
break;
case "two":
Console.Write(2);
break;
case "three":
Console.Write(3);
break;
}
}
Console.WriteLine();
}
}
The output is shown here:
12321
VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
c# combine pdf; pdf split and merge
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
acrobat merge pdf files; acrobat combine pdf files
8
A Closer Look at 
Methods and Classes
T
his chapter resumes the examination of classes and methods. It begins by explaining 
how to control access to the members of a class. It then discusses the passing and 
returning of objects, method overloading, the various forms of Main( ), recursion, 
and the use of the keyword static.
Controlling Access to Class Members
In its support for encapsulation, the class provides two major benefits. First, it links data 
with code. Y
Second, it provides the means by which access to members can be controlled. It is this 
second feature that is examined here.
Although C#’s approach is a bit more sophisticated, in essence, there are two basic 
types of class members: public and private. A public member can be freely accessed by code 
this point. A
through the use of private members that access is controlled.
ogramming 
because it helps prevent the misuse of an object. By allowing access to private data only 
through a well-defined set of methods, you can prevent improper values from being assigned 
the class to set the value of a private member directly. You can also control precisely how 
and when the data within an object is used. Thus, when correctly implemented, a class 
cre not open to 
tampering.
C#’s Access Modifiers
Member access control is achieved through the use of four accessmodifiers:public,private,
protected, and internal. In this chapter, we will be concerned with public and private. The 
protected1. 
167
CHAPTER
VB.NET PDF- HTML5 PDF Viewer for VB.NET Project
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
combine pdf files; reader create pdf multiple files
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
pdf combine two pages into one; add pdf files together
168
Part I: The C# Language
Theinternal modifier applies mostly to the use of an assembly, which for C# loosely means 
a deployable program or library. The internal modifier is examined in Chapter 16.
When a member of a class is modified by the public specifier, that member can be 
accessed by any other code in your program. This includes methods defined inside other 
classes.
When a member of a class is specified as private, then that member can be accessed only 
by other members of its class. Thus, methods in other classes are not able to access a private
member of another class. As explained in Chapter 6, if no access specifier is used, a class 
member is private to its class by default. Thus, the private specifier is optional when creating 
private class members.
An access specifier precedes the rest of a member’s type specification. That is, it must 
begin a member’s declaration statement. Here are some examples:
public string errMsg;
private double bal;
private bool isError(byte status) { // ...
To understand the difference between public and private, consider the following 
program:
// Public vs. private access.
using System;
class MyClass {
private int alpha; // private access explicitly specified
int beta;          // private access by default
public int gamma;  // public access
// Methods to access alpha and beta. It is OK for a member
// of a class to access a private member of the same class.
public void SetAlpha(int a) {
alpha = a;
}
public int GetAlpha() {
return alpha;
}
public void SetBeta(int a) {
beta = a;
}
public int GetBeta() {
return beta;
}
}
class AccessDemo {
static void Main() {
MyClass ob = new MyClass();
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
PDF ›› C# PDF: Extract PDF Image. How to C#: Extract Image from PDF Document. Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document.
adding pdf pages together; pdf merge
VB.NET PDF Text Extract Library: extract text content from PDF
PDF ›› VB.NET PDF: Extract PDF Text. VB.NET PDF - Extract Text from PDF Using VB. How to Extract Text from PDF with VB.NET Sample Codes in .NET Application.
c# pdf merge; pdf mail merge
P
A
R
T
I
Chapter 8: A Closer Look at Methods and Classes 
169
P
A
R
T
I
P
A
R
T
I
// Access to alpha and beta is allowed only through methods.
ob.SetAlpha(-99);
ob.SetBeta(19);
Console.WriteLine("ob.alpha is " + ob.GetAlpha());
Console.WriteLine("ob.beta is " + ob.GetBeta());
// You cannot access alpha or beta like this:
//  ob.alpha = 10; // Wrong! alpha is private!
//  ob.beta = 9;   // Wrong! beta is private!
// It is OK to directly access gamma because it is public.
ob.gamma = 99;
}
}
As you can see, inside the MyClass class, alphais specified as private,beta is private by 
default, and gamma is specified as public. Because alpha and beta are private, they cannot 
be accessed by code outside of their class. Therefore, inside the AccessDemo class, neither 
can be used directly. Each must be accessed through public methods, such as SetAlpha( )
andGetAlpha( ). For example, if you were to remove the comment symbol from the 
beginning of the following line
//  ob.alpha = 10; // Wrong! alpha is private!
you would not be able to compile this program because of the access violation. Although 
access to alpha by code outside of MyClass is not allowed, methods defined within 
MyClass can freely access it, as the SetAlpha( ) and GetAlpha( ) methods show. The same 
is true for beta.
The key point is this: A private member can be used freely by other members of its class, 
but it cannot be accessed by code outside its class.
Applying Public and Private Access
The pr
programming. Although there are no hard and fast rules, here are some general principles 
that serve as guidelines:
• Members of a class that are used only within the class itself should be private.
• 
provided through public methods that can perform range checks.
• If changing a member can cause an effect that extends beyond the member itself 
(that is, affects other aspects of the object), that member should be private, and 
access to it should be controlled.
• Members that can cause harm to an object when improperly used should be private. 
Access to these members should be through public methods that prevent improper 
usage.
• Methods that get and set the values of private data must be public.
• Public instance variables are permissible when there is no reason for them to be 
private.
170
Part I: The C# Language
Of course, there are many nuances that the preceding rules do not address, and special 
cases cause one or more rules to be violated. But, in general, if you follow these rules, you 
will be creating resilient objects that are not easily misused.
Controlling Access: A Case Study
To better understand the “how and why” behind access control, a case study is useful. One 
of the quintessential examples of object-oriented programming is a class that implements a 
stack. As you probably know, a stack is a data structure that implements a last-in, first-out 
list. Its name comes from the analogy of a stack of plates on a table. The first plate on the 
table is the last one to be used.
A stack is a classic example of object-oriented programming because it combines storage 
data
engine that enfor
a class in which the members that provide storage for the stack are private, and public methods 
pr
the stack to access the elements out of order.
A stack defines two basic operations: push and pop. A push puts a value onto the top of 
the stack. A pop removes a value from the top of the stack. Thus, a pop is consumptive; once 
a value has been popped off the stack, it has been removed and cannot be accessed again.
The example shown here creates a class called Stack that implements a stack. The 
underlying storage for the stack is provided by a private array. The push and pop operations 
are available through the public methods of the Stack class. Thus, the public methods enforce 
the last-in, first-out mechanism. As shown here, the Stack class stores characters, but the 
same mechanism could be used to store any type of data:
// A stack class for characters.
using System;
class Stack {
// These members are private.
char[] stck; // holds the stack
int tos;     // index of the top of the stack
// Construct an empty Stack given its size.
public Stack(int size) {
stck = new char[size]; // allocate memory for stack
tos = 0;
}
// Push characters onto the stack.
public void Push(char ch) {
if(tos==stck.Length) {
Console.WriteLine(" -- Stack is full.");
return;
}
stck[tos] = ch;
tos++;
}
// Pop a character from the stack.
P
A
R
T
I
Chapter 8: A Closer Look at Methods and Classes 
171
P
A
R
T
I
P
A
R
T
I
public char Pop() {
if(tos==0) {
Console.WriteLine(" -- Stack is empty.");
return (char) 0;
}
tos--;
return stck[tos];
}
// Return true if the stack is full.
public bool IsFull() {
return tos==stck.Length;
}
// Return true if the stack is empty.
public bool IsEmpty() {
return tos==0;
}
// Return total capacity of the stack.
public int Capacity() {
return stck.Length;
}
// Return number of objects currently on the stack.
public int GetNum() {
return tos;
}
}
Let’s examine this class closely. The Stack class begins by declaring these two instance 
variables:
// These members are private.
char[] stck; // holds the stack
int tos;     // index of the top of the stack
Thestck array provides the underlying storage for the stack, which in this case holds 
by the Stack constructor. The tos member holds the index of the top of the stack.
Both the tos and stck members are private. This enforces the last-in, first-out stack 
mechanism. If public access to stck were allowed, then the elements on the stack could 
be accessed out of order. Also, since tos holds the index of the top element in the stack, 
manipulations of tos by code outside the Stack class must be prevented in order to avoid 
corruption of the stack. Access to stck and tos is available, indirectly, to the user of Stack
through the various public methods described shortly.
The stack constructor is shown next:
// Construct an empty Stack given its size.
public Stack(int size) {
stck = new char[size]; // allocate memory for stack
tos = 0;
}
172
Part I: The C# Language
The constructor is passed the desired size of the stack. It allocates the underlying array and 
setstos to zero. Thus, a zero value in tos indicates that the stack is empty.
The public Push( ) method puts an element onto the stack. It is shown here:
// Push characters onto the stack.
public void Push(char ch) {
if(tos==stck.Length) {
Console.WriteLine(" -- Stack is full.");
return;
}
stck[tos] = ch;
tos++;
}
The element to be pushed onto the stack is passed in ch. Before the element is added to 
the stack, a check is made to ensure that there is still room in the underlying array. This is 
done by making sure that tos does not exceed the length of stck. If there is still room, the 
element is stored in stck at the index specified by tos, and then tos is incremented. Thus, 
tos always contains the index of the next free element in stck.
To remove an element from the stack, call the public method Pop( ). It is shown here:
// Pop a character from the stack.
public char Pop() {
if(tos==0) {
Console.WriteLine(" -- Stack is empty.");
return (char) 0;
}
tos--;
return stck[tos];
}
Here, the value of tos is checked. If it is zero, the stack is empty. Otherwise, tos is 
decremented, and the element at that index is returned.
AlthoughPush( ) and Pop( ) are the only methods needed to implement a stack, some 
others are quite useful, and the Stack class defines four more. These are IsFull( ),IsEmpty( ),
Capacity( ), and GetNum( ), and they provide information about the state of the stack. They 
are shown here:
// Return true if the stack is full.
public bool IsFull() {
return tos==stck.Length;
}
// Return true if the stack is empty.
public bool IsEmpty() {
return tos==0;
}
// Return total capacity of the stack.
P
A
R
T
I
Chapter 8: A Closer Look at Methods and Classes 
173
P
A
R
T
I
P
A
R
T
I
public int Capacity() {
return stck.Length;
}
// Return number of objects currently on the stack.
public int GetNum() {
return tos;
}
TheIsFull( ) method returns true when the stack is full and false otherwise. The IsEmpty( )
method returns true when the stack is empty and false otherwise. To obtain the total capacity 
Capacity( ). To obtain the 
number of elements currently stored on the stack, call GetNum( ). These methods are useful 
because the information they provide requires access to tos, which is private. They are also 
examples of how public methods can provide safe access to private members.
The following program demonstrates the stack:
// Demonstrate the Stack class.
using System;
class StackDemo {
static void Main() {
Stack stk1 = new Stack(10);
Stack stk2 = new Stack(10);
Stack stk3 = new Stack(10);
char ch;
int i;
// Put some characters into stk1.
Console.WriteLine("Push A through J onto stk1.");
for(i=0; !stk1.IsFull(); i++)
stk1.Push((char) ('A' + i));
if(stk1.IsFull()) Console.WriteLine("stk1 is full.");
// Display the contents of stk1.
Console.Write("Contents of stk1: ");
while( !stk1.IsEmpty() ) {
ch = stk1.Pop();
Console.Write(ch);
}
Console.WriteLine();
if(stk1.IsEmpty()) Console.WriteLine("stk1 is empty.\n");
// Put more characters into stk1.
Console.WriteLine("Again push A through J onto stk1.");
for(i=0; !stk1.IsFull(); i++)
stk1.Push((char) ('A' + i));
// Now, pop from stk1 and push the element in stk2.
Documents you may be interested
Documents you may be interested