asp net core 2.0 mvc pdf : Batch merge pdf application Library cloud html asp.net azure class McGraw.Hill.CSharp.4.0.The.Complete.Reference.Apr.201040-part1199

374
Part I: The C# Language
The Character Stream Wrapper Classes
To create a character stream, wrap a byte stream inside one of the character stream 
wrappers. At the top of the character stream hierarchy are the abstract classes TextReader
andTextWriter.TextReader handles input, and TextWriter handles output. The methods 
defined by these two abstract classes are available to all of their subclasses. Thus, they form 
a minimal set of I/O functions that all character streams will have.
Table 14-3 shows the input methods in TextReader. In general, these methods can throw 
anIOException on error. (Some can throw other types of exceptions, too.) Of particular 
interest is the ReadLine( ) method, which reads an entire line of text, returning it as a string.
This method is useful when reading input that contains embedded spaces. TextReader also 
specifies the Close( ) method, shown here:
void Close()
It closes the reader and frees its resources.
TextWriter defines versions of Write( ) and WriteLine( ) that output all of the built-in 
types. For example, here are just a few of their overloaded versions:
Method
Description
void Write(int value)
Writes an int. 
void Write(double value)
Writes a double.
void Write(bool value)
Writes a bool.
void WriteLine(string value)
Writes a string followed by a newline.
void WriteLine(uint value)
Writes a uint followed by a newline.
void WriteLine(char value)
Writes a char followed by a newline.
Method
Description
int Peek( )
Obtains the next character from the input stream, but does not 
remove that character. Returns –1 if no character is available.
int Read( )
Returns an integer representation of the next available 
character from the invoking input stream. Returns –1 when 
the end of the stream is encountered.
int Read(char[ ] buffer, int index,
int count)
Attempts to read up to count characters into buffer starting 
at buffer[count], returning the number of characters 
successfully read. 
int ReadBlock(char[ ] buffer, int index,
int count)
Attempts to read up to count characters into buffer starting at 
buffer[index], returning the number of characters successfully 
read. 
string ReadLine( )
Reads the next line of text and returns it as a string. Null is 
returned if an attempt is made to read at end-of-file.
string ReadToEnd( )
Reads all of the remaining characters in a stream and returns 
them as a string.
T
ABLE
14-3  The Input Methods Defi ned by TextReader
Batch 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
append pdf files reader; pdf merge comments
Batch 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
acrobat merge pdf files; reader combine pdf
P
A
R
T
I
Chapter 14: Using I/O 
375
P
A
R
T
I
P
A
R
T
I
All throw an IOException if an error occurs while writing.
TextWriter also specifies the Close( ) and Flush( ) methods shown here:
virtual void Close( )
virtual void Flush( )
Flush( ) causes any data remaining in the output buffer to be written to the physical 
medium.Close( ) closes the writer and frees its resources.
TheTextReader and TextWriter classes are implemented by several character-based 
stream classes, including those shown here. Thus, these streams provide the methods and 
properties specified by TextReader and TextWriter.
Stream Class
Description
StreamReader
Reads characters from a byte stream. This class wraps a byte input stream.
StreamWriter
Writes characters to a byte stream. This class wraps a byte output stream.
StringReader
Reads characters from a string.
StringWriter
Writes characters to a string.
Binary Streams
In addition to the byte and character streams, there are two binary stream classes that can 
be used to read and write binary data directly. These streams are called BinaryReader and 
BinaryWriter. W
discussed.
Now that you understand the general layout of the I/O system, the rest of this chapter 
will examine its various pieces in detail, beginning with console I/O.
Console I/O
Console I/O is accomplished through the standard streams Console.In,Console.Out, and 
Console.Error. Console I/O has been used since Chapter 2, so you are already familiar with 
it. As you will see, it has some additional capabilities.
Before we begin, however, it is important to emphasize a point made earlier in this 
book: Most real applications of C# will not be text-based, console programs. Rather, they 
will be graphically oriented programs or components that rely upon a windowed interface 
for interaction with the user, or will be server-side code. Thus, the portion of the I/O system 
that relates to console input and output is not widely used. Although text-based programs 
are excellent as teaching examples, for short utility programs, and for some types of 
components, they are not suitable for most real-world applications.
Reading Console Input
Console.In is an instance of TextReader, and you can use the methods and properties 
defined by TextReader to access it. However, you will usually use the methods provided by 
Console, which automatically read from Console.In.Console defines three input methods. 
The first two, Read( ) and ReadLine( ), have been available since .NET Framework 1.0. The 
third, ReadKey( ), was added by .NET Framework 2.0.
VB.NET Image: PDF to Image Converter, Convert Batch PDF Pages to
VB.NET Imaging - Convert PDF to Image Using VB. VB.NET Code for Converting PDF to Image within .NET Imaging Converting SDK. Visual
apple merge pdf; acrobat combine pdf files
Convert Images, Batch Conversion in .NET Winfroms| Online
VB.NET File: Merge PDF; VB.NET File: Split PDF Generator. PDF Reader. Twain Scanning. DICOM Reading. speed; Include single image conversion; Support batch conversion
append pdf; add pdf files together
376
Part I: The C# Language
To read a single character, use the Read( ) method:
static int Read( )
Read( ) returns the next character read from the console. It waits until the user presses a 
key and then returns the result. The character is returned as an int, which must be cast to 
char.Read( ) returns –1 on error. This method will throw an IOException on failure. When 
usingRead( ), console input is line-buffered, so you must press enter before any character 
that you type will be sent to your program.
Here is a program that reads a character from the keyboard using Read( ):
// Read a character from the keyboard.
using System;
class KbIn {
static void Main() {
char ch;
Console.Write("Press a key followed by ENTER: ");
ch = (char) Console.Read(); // get a char
Console.WriteLine("Your key is: " + ch);
}
}
Here is a sample run:
Press a key followed by ENTER: t
Your key is: t
The fact that Read( ) is line-buffered is a source of annoyance at times. When you press 
enter, a carriage-return, line-feed sequence is entered into the input stream. Furthermore, 
these characters are left pending in the input buffer until you read them. Thus, for some 
applications, you may need to remove them (by reading them) before the next input operation. 
(To read keystrokes from the console in a non-line-buffered manner, you can use ReadKey( ),
described later in this section.)
To read a string of characters, use the ReadLine( ) method. It is shown here:
static string ReadLine( )
ReadLine( ) reads characters until you press enterand returns them in a string object. This 
method will throw an IOException if an I/O error occurs.
Here is a program that demonstrates reading a string from Console.In by using 
ReadLine( ):
// Input from the console using ReadLine().
using System;
class ReadString {
static void Main() {
string str;
Convert Image & Documents Formats in Web Viewer| Online Tutorials
VB.NET File: Merge PDF; VB.NET File: Split PDF Generator. PDF Reader. Twain Scanning. DICOM Reading. Support for single conversion; Include batch conversion; Convert
build pdf from multiple files; split pdf into multiple files
C# PDF: Use C# APIs to Control Fully on PDF Rendering Process
toolkit, users are able to control rendered image resolution, region size of PDF page or rendered picture, as well as batch or individual PDF to image
combine pdf; merge pdf online
P
A
R
T
I
Chapter 14: Using I/O 
377
P
A
R
T
I
P
A
R
T
I
Console.WriteLine("Enter some characters.");
str = Console.ReadLine();
Console.WriteLine("You entered: " + str);
}
}
Here is a sample run:
Enter some characters.
This is a test.
You entered: This is a test.
Although the Console methods are the easiest way to read from Console.In, you can 
call methods on the underlying TextReader. For example, here is the preceding program 
rewritten to use the ReadLine( ) method defined by TextReader:
// Read a string from the keyboard, using Console.In directly.
using System;
class ReadChars2 {
static void Main() {
string str;
Console.WriteLine("Enter some characters.");
Console.WriteLine("You entered: " + str);
}
}
Notice how ReadLine( ) is now invoked directly on Console.In. The key point here is that 
if you need access to the methods defined by the TextReader that underlies Console.In, you 
will invoke those methods as shown in this example.
Using ReadKey( )
The .NET Framework includes a method in Console that enables you to read individual 
keystrokes directly from the keyboard, in a non-line-buffered manner. This method is called 
ReadKey( ). When it is called, it waits until a key is pressed. When a key is pressed, ReadKey( )
returns the keystroke immediately. The user does not need to press enter. Thus, ReadKey( )
allows keystrokes to be read and processed in real time.
ReadKey( ) has these two forms:
static ConsoleKeyInfo ReadKey( )
static ConsoleKeyInfo ReadKey(bool intercept)
The first form waits for a key to be pressed. When that occurs, it returns the key and also 
displays the key on the screen. The second form also waits for and returns a keypress. 
However, if intercept is true, then the key is not displayed. If intercept is false, the key is 
displayed.
VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
NET convert PDF to Jpeg, VB.NET compress PDF, VB.NET print PDF, VB.NET merge PDF files, VB Professional .NET PDF converter control for batch conversion.
combine pdfs online; c# merge pdf
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
text from PDF, VB.NET convert PDF to Jpeg, VB.NET compress PDF, VB.NET print PDF, VB.NET merge PDF files, VB.NET Professional .NET PDF batch conversion control.
combine pdf files; add pdf together
378
Part I: The C# Language
ReadKey( ) returns information about the keypress in an object of type 
ConsoleKeyInfo, which is a structure. It contains the following read-only properties:
char KeyChar
ConsoleKey Key
ConsoleModifi ers Modifi ers
KeyChar contains the char equivalent of the character that was pressed. Key contains a 
value from the ConsoleKey enumeration, which is an enumeration of all the keys on the 
keyboard. Modifiers describes which, if any, of the keyboard modifiers atl,ctrl, or shift
were pressed when the keystroke was generated. These modifiers are represented by the 
ConsoleModifiers enumeration, which has these values: Control,Shift, and Alt. More than 
one modifier value might be present in Modifiers.
The major advantage to ReadKey( ) is that it provides a means of achieving interactive 
keyboard input because it is not line buffered. To see this effect, try the following program:
// Read keystrokes from the console by using ReadKey().
using System;
class ReadKeys {
static void Main() {
ConsoleKeyInfo keypress;
Console.WriteLine("Enter keystrokes. Enter Q to stop.");
do {
keypress = Console.ReadKey(); // read keystrokes
Console.WriteLine(" Your key is: " + keypress.KeyChar);
// Check for modifier keys.
if((ConsoleModifiers.Alt & keypress.Modifiers) != 0)
Console.WriteLine("Alt key pressed.");
if((ConsoleModifiers.Control & keypress.Modifiers) != 0)
Console.WriteLine("Control key pressed.");
if((ConsoleModifiers.Shift & keypress.Modifiers) != 0)
Console.WriteLine("Shift key pressed.");
} while(keypress.KeyChar != 'Q');
}
}
Here is a sample run:
Enter keystrokes. Enter Q to stop.
a Your key is: a
b Your key is: b
d Your key is: d
A Your key is: A
Shift key pressed.
B Your key is: B
Shift key pressed.
C Your key is: C
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
NET. .NET library to batch convert PDF files to jpg image files. High quality jpeg file can be exported from PDF in .NET framework.
c# merge pdf files; batch combine pdf
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
fonts fast. Professional .NET PDF converter component for batch conversion. Merge all Excel sheets to one PDF file in VB.NET. Change
add pdf files together reader; c# merge pdf files into one
P
A
R
T
I
Chapter 14: Using I/O 
379
P
A
R
T
I
P
A
R
T
I
Shift key pressed.
● Your key is: ●
Control key pressed.
Q Your key is: Q
Shift key pressed.
As the output confirms, each time a key is pressed, ReadKey( ) immediately returns the 
keypress. As explained, this differs from Read( ) and ReadLine( ), which use line-buffered 
input. Therefore, if you want to achieve interactive responses from the keyboard, use 
ReadKey( ).
Writing Console Output
Console.Out and Console.Error are objects of type TextWriter. Console output is most 
easily accomplished with Write( ) and WriteLine( ), with which you are already familiar. 
Versions of these methods exist that output each of the built-in types. Console defines its 
own versions of Write( ) and WriteLine( ) so they can be called directly on Console, as you 
have been doing throughout this book. However, you can invoke these (and other) methods 
on the TextWriter that underlies Console.Out and Console.Error, if you choose.
Here is a program that demonstrates writing to Console.Out and Console.Error. By 
default, both write to the console.
// Write to Console.Out and Console.Error.
using System;
class ErrOut {
static void Main() {
int a=10, b=0;
int result;
Console.Out.WriteLine("This will generate an exception.");
try {
result = a / b; // generate an exception
} catch(DivideByZeroException exc) {
Console.Error.WriteLine(exc.Message);
}
}
}
The output from the program is shown here:
This will generate an exception.
Attempted to divide by zero.
Sometimes newcomers to programming are confused about when to use Console.Error.
Since both Console.Out and Console.Error default to writing their output to the console, 
why are there two different streams? The answer lies in the fact that the standard streams 
can be redirected to other devices. For example, Console.Error can be redirected to write to 
a disk file, rather than the screen. Thus, it is possible to direct error output to a log file, for 
example, without affecting console output. Conversely, if console output is redirected and 
error output is not, then error messages will appear on the console, where they can be seen. 
We will examine redirection later, after file I/O has been described.
380
Part I: The C# Language
FileStream and Byte-Oriented File I/O
The .NET Framework provides classes that allow you to read and write files. Of course, the 
most common type of files are disk files. At the operating system level, all files are byte 
oriented. As you would expect, there are methods to read and write bytes from and to a file. 
Thus, reading and writing files using byte streams is very common. You can also wrap a 
byte-oriented file stream within a character-based object. Character-based file operations are 
useful when text is being stored. Character streams are discussed later in this chapter. Byte-
oriented I/O is described here.
To create a byte-oriented stream attached to a file, you will use the FileStream class. 
FileStream is derived from Stream and contains all of Stream’s functionality.
Remember, the stream classes, including FileStream, are defined in System.IO. Thus, 
you will usually include
using System.IO;
near the top of any program that uses them.
Opening and Closing a File
To create a byte stream linked to a file, create a FileStreamobject.FileStream defines 
several constructors. Perhaps its most commonly used one is shown here:
FileStream(string path, FileMode mode)
Here, path
Themode
defined by the FileMode enumeration. These values are shown in Table 14-4. In general, 
this constructor opens a file for read/write access. The exception is when the file is opened 
usingFileMode.Append. In this case, the file is write-only.
If a failure occurs when attempting to open the file, an exception will be thrown. If the 
file cannot be opened because it does not exist, FileNotFoundException will be thrown. If 
the file cannot be opened because of some type of I/O error, IOException will be thrown. 
Other exceptions include ArgumentNullException (the filename is null), ArgumentException
(the filename is invalid), ArgumentOutOfRangeException (the mode is invalid), 
SecurityException (user does not have access rights), PathTooLongException (the 
Value
Description
FileMode.Append
Output is appended to the end of file.
FileMode.Create
Creates a new output file. Any preexisting file by the same name will 
be destroyed.
FileMode.CreateNew
Creates a new output file. The file must not already exist.
FileMode.Open
Opens a preexisting file.
FileMode.OpenOrCreate
Opens a file if it exists, or creates the file if it does not already exist.
FileMode.Truncate
Opens a preexisting file, but reduces its length to zero.
T
ABLE
14-4  The FileMode Values
P
A
R
T
I
Chapter 14: Using I/O 
381
P
A
R
T
I
P
A
R
T
I
filename/path is too long), NotSupportedException (the filename specifies an unsupported 
device), and DirectoryNotFoundException(specified directory is invalid).
The exceptions PathTooLongException,DirectoryNotFoundException, and 
FileNotFoundException are subclasses of IOException. Thus, it is possible to catch 
all three by catching IOException.
There are many ways to handle the process of opening a file. The following shows one 
way. It opens a file called test.dat for input.
FileStream fin = null;
try {
fin = new FileStream("test", FileMode.Open);
}
catch(IOException exc) { // catch all I/O exceptions
Console.WriteLine(exc.Message);
// Handle the error.
}
catch(Exception exc { // catch any other exception
Console.WriteLine(exc.Message);
// Handle the error, if possible.
// Rethrow those exceptions that you don't handle.
}
Here, the first catch clause handles situations in which the file is not found, the path is 
too long, the directory does not exist, or other I/O errors occur. The second catch, which 
ors 
(possibly by rethrowing the exception). You could also check for each exception individually, 
reporting more specifically the problem that occurred and taking remedial action specific 
to that error.
For the sake of simplicity, the examples in this book will catch only IOException, but 
your real-world code may (probably will) need to handle the other possible exceptions, 
depending upon the circumstances. Also, the exception handlers in this chapter simply 
report the error, but in many cases, your code should take steps to correct the problem 
when possible. For example, you might reprompt the user for a filename if the one 
previously entered is not found. You might also need to rethrow the exception.
R
EMEMBER
R
EMEMBER
To keep the code simple, the examples in this chapter catch only IOException, but 
individually.
As mentioned, the FileStream constructor just described opens a file that (in most cases) 
has read/write access. If you want to restrict access to just reading or just writing, use this 
constructor instead:
FileStream(string path, FileMode mode, FileAccess access)
As before, path specifies the name of the file to open, and mode specifies how the file will be 
opened. The value passed in access specifies how the file can be accessed. It must be one of 
the values defined by the FileAccess enumeration, which are shown here:
FileAccess.Read
FileAccess.Write
FileAccess.ReadWrite
382
Part I: The C# Language
For example, this opens a read-only file:
When you are done with a file, you must close it. This can be done by calling Close( ).
Its general form is shown here:
void Close( )
Closing a file releases the system resources allocated to the file, allowing them to be used by 
another file. As a point of interest, Close( ) works by calling Dispose( ), which actually frees 
the resources.
N
OTE
N
OTE
Theusing
it is no longer needed. This approach is beneficial in many file-handling situations because it 
provides a simple means to ensure that a file is closed when it is no longer needed. However, to 
closed, this chapter explicitly calls Close( ) in all cases.
Reading Bytes from a FileStream
FileStream defines two methods that read bytes from a file: ReadByte( ) and Read( ). To 
read a single byte from a file, use ReadByte( ), whose general form is shown here:
int ReadByte( )
Each time it is called, it reads a single byte from the file and returns it as an integer value. 
It returns –1 when the end of the file is encountered. Possible exceptions include 
NotSupportedException (the stream is not opened for input) and ObjectDisposedException
(the stream is closed).
To read a block of bytes, use Read( ), which has this general form:
int Read(byte[ ] array, int offset, int count)
Read( ) attempts to read up to count bytes into array starting at array[offset]. It returns the 
number of bytes successfully read. An IOException is thrown if an I/O error occurs. Several 
other types of exceptions are possible, including NotSupportedException, which is thrown 
if reading is not supported by the stream.
The following program uses ReadByte( ) to input and display the contents of a text file, 
the name of which is specified as a command-line argument. Note the program first checks 
that a filename has been specified before trying to open the file.
/* Display a text file.
To use this program, specify the name of the file that you
want to see. For example, to see a file called TEST.CS,
use the following command line.
ShowFile TEST.CS
*/
using System;
using System.IO;
P
A
R
T
I
Chapter 14: Using I/O 
383
P
A
R
T
I
P
A
R
T
I
class ShowFile {
static void Main(string[] args) {
int i;
FileStream fin;
if(args.Length != 1) {
Console.WriteLine("Usage: ShowFile File");
return;
}
try {
fin = new FileStream(args[0], FileMode.Open);
} catch(IOException exc) {
Console.WriteLine("Cannot Open File");
Console.WriteLine(exc.Message);
return; // File can't be opened, so stop the program.
}
// Read bytes until EOF is encountered.
try {
do {
i = fin.ReadByte();
if(i != -1) Console.Write((char) i);
} while(i != -1);
} catch(IOException exc) {
Console.WriteLine("Error Reading File");
Console.WriteLine(exc.Message);
} finally {
fin.Close();
}
}
}
Notice that the program uses two try blocks. The first catches any I/O exceptions that 
might prevent the file from being opened. If an I/O error occurs, the program terminates. 
Otherwise, the second try block monitors the read operation for I/O exceptions. Thus, the 
secondtry block executes only if fin refers to an open file. Also, notice that the file is closed 
in the finally block associated with the second try block. This means that no matter how the 
do loop ends (either normally or because of an error), the file will be closed. Although not 
an issue in this specific example (because the entire program ends at that point anyway), 
the advantage to this approach, in general, is that if the code that accesses a file terminates 
because of some exception, the file is still closed by the finally block. This ensures that the 
file is closed in all cases.
In some situations, it may be easier to wrap the portions of a program that open the file 
and access the file within a single try block (rather than separating the two). For example, 
here is another, shorter way to write the ShowFile program:
// Display a text file. Compact version.
using System;
Documents you may be interested
Documents you may be interested