asp net core 2.0 mvc pdf : Batch combine pdf application software cloud html windows web page class McGraw.Hill.CSharp.4.0.The.Complete.Reference.Apr.201041-part1200

384
Part I: The C# Language
using System.IO;
class ShowFile {
static void Main(string[] args) {
int i;
FileStream fin = null;
if(args.Length != 1) {
Console.WriteLine("Usage: ShowFile File");
return;
}
// Use a single try block to open the file and then
// read from it.
try {
fin = new FileStream(args[0], FileMode.Open);
// Read bytes until EOF is encountered.
do {
i = fin.ReadByte();
if(i != -1) Console.Write((char) i);
} while(i != -1);
} catch(IOException exc) {
Console.WriteLine("I/O Error:\n" + exc.Message);
} finally {
if(fin != null) fin.Close();
}
}
}
Notice in this version that the FileStream reference fin is initialized to null. If the file 
can be opened by the FileStream constructor, fin will be non-null. If the constructor fails, 
fin will remain null. This is important because inside the finally block, Close( ) is called 
only if fin is not null. This mechanism prevents an attempt to call Close( ) on fin when it 
does not refer to an open file. Because of its compactness, this approach is used by many of 
the I/O examples in this book. Be aware, however, that it will not be appropriate in cases in 
which you want to deal separately with a failure to open a file, such as might occur if a user 
mistypes a filename. In such a situation, you might want to prompt for the correct name, for 
example, before entering a try block that accesses the file.
In general, precisely how you manage the opening, accessing, and closing of a file 
appropriate for another. Thus, you must tailor this process to best fit the exact needs of your 
program.
Writing to a File
To write a byte to a file, use the WriteByte( ) method. Its simplest form is shown here:
void WriteByte(byte value)
This method writes the byte specified by value to the file. If the underlying stream is not 
opened for output, a NotSupportedException is thrown. If the stream is closed, 
ObjectDisposedException is thrown.
Batch combine pdf - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
reader combine pdf pages; reader merge pdf
Batch combine 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
pdf merge files; add two pdf files together
P
A
R
T
I
Chapter 14: Using I/O 
385
P
A
R
T
I
P
A
R
T
I
You can write an array of bytes to a file by calling Write( ). It is shown here:
void Write(byte[ ] array, int offset, int count)
Write( ) writes count bytes from the array array, beginning at array[offset], to the file. If an 
error occurs during writing, an IOException is thrown. If the underlying stream is not 
opened for output, a NotSupportedException is thrown. Several other exceptions are also 
possible.
As you may know, when file output is performed, often that output is not immediately 
written to the actual physical device. Instead, output is buffered by the operating system 
until a sizable chunk of data can be written all at once. This improves the efficiency of the 
system. For example, disk files are organized by sectors, which might be anywhere from 
128 bytes long, on up. Output is usually buffered until an entire sector can be written all at 
once. However
buffer is full or not, you can call Flush( ), shown here:
void Flush( )
AnIOException is thrown on failure. If the stream is closed, ObjectDisposedException is 
thrown.
Once you are done with an output file, you must remember to close it. This can be done 
by calling Close( ). Doing so ensures that any output remaining in a disk buffer is actually 
written to the disk. Thus, there is no reason to call Flush( ) before closing a file.
Here is a simple example that writes to a file:
// Write to a file.
using System;
using System.IO;
class WriteToFile {
static void Main(string[] args) {
FileStream fout = null;
try {
// Open output file.
fout = new FileStream("test.txt", FileMode.CreateNew);
// Write the alphabet to the file.
for(char c = 'A'; c <= 'Z'; c++)
fout.WriteByte((byte) c);
} catch(IOException exc) {
Console.WriteLine("I/O Error:\n" + exc.Message);
} finally {
if(fout != null) fout.Close();
}
}
}
The program first creates a file called test.txt for output by using FileMode.CreateNew.
This means that the file must not already exist. (If it does exist, an IOException will be 
thrown.) After the file is open, the uppercase alphabet is written to the file. Once this 
program executes, test.txt will contain the following output:
ABCDEFGHIJKLMNOPQRSTUVWXYZ
VB.NET Word: Merge Multiple Word Files & Split Word Document
destnPath As [String]) DOCXDocument.Combine(docList, destnPath or separate Word file in batch mode within & profession imaging controls, PDF document, image to
pdf merger online; c# merge pdf pages
C# Create PDF from Tiff Library to convert tif images to PDF in C#
NET component for batch converting tiff images to PDF documents in C# class. Support to combine multiple page tiffs into one PDF file.
combine pdf online; reader create pdf multiple files
386
Part I: The C# Language
Using FileStream to Copy a File
One advantage to the byte-oriented I/O used by FileStream is that you can use it on any 
ogram copies 
any type of file, including executable files. The names of the source and destination files 
are specified on the command line.
/* Copy a file one byte at a time.
To use this program, specify the name of the source
file and the destination file. For example, to copy a
file called FIRST.DAT to a file called SECOND.DAT, use
the following command line:
CopyFile FIRST.DAT SECOND.DAT
*/
using System;
using System.IO;
class CopyFile {
static void Main(string[] args) {
int i;
FileStream fin = null;
FileStream fout = null;
if(args.Length != 2) {
Console.WriteLine("Usage: CopyFile From To");
return;
}
try {
// Open the files.
fin = new FileStream(args[0], FileMode.Open);
fout = new FileStream(args[1], FileMode.Create);
// Copy the file.
do {
i = fin.ReadByte();
if(i != -1) fout.WriteByte((byte)i);
} while(i != -1);
} catch(IOException exc) {
Console.WriteLine("I/O Error:\n" + exc.Message);
} finally {
if(fin != null) fin.Close();
if(fout != null) fout.Close();
}
}
}
C# Word - Process Word Document in C#
single or batch pages in Word document in C#.NET. Able to sort order of Office Word document pages through C# programming. C# coding to merge / combine two or
merge pdf; .net merge pdf files
P
A
R
T
I
Chapter 14: Using I/O 
387
P
A
R
T
I
P
A
R
T
I
Character-Based File I/O
-based 
streams for this purpose. The advantage to the character streams is that they operate 
directly on Unicode characters. Thus, if you want to store Unicode text, the character 
streams are certainly your best option. In general, to perform character-based file 
operations, you will wrap a FileStream inside either a StreamReader or a StreamWriter.
These classes automatically convert a byte stream into a character stream, and vice versa.
Remember
StreamReader or StreamWriter does not alter this fact.
StreamWriter is derived from TextWriter.StreamReader is derived from TextReader.
Thus,StreamWriter and StreamReader have access to the methods and properties defined 
by their base classes.
Using StreamWriter
To create a character-based output stream, wrap a Stream object (such as a FileStream)
inside a StreamWriter.StreamWriter defines several constructors. One of its most popular 
is shown here:
StreamWriter(Stream stream)
Here, stream is the name of an open stream. This constructor throws an ArgumentException
ifstream is not opened for output and an ArgumentNullException if stream is null. Once 
created, a StreamWriter automatically handles the conversion of characters to bytes. When 
you are done with the StreamWriter, you must close it. Closing the StreamWriter also 
closes the underlying stream.
Here is a simple key-to-disk utility that reads lines of text entered at the keyboard and 
writes them to a file called test.txt. Text is read until the user enters the word “stop”. It uses 
aFileStream wrapped in a StreamWriter to output to the file.
// A simple key-to-disk utility that demonstrates a StreamWriter.
using System;
using System.IO;
class KtoD {
static void Main() {
string str;
FileStream fout;
// First, open the file stream.
try {
fout = new FileStream("test.txt", FileMode.Create);
}
catch(IOException exc) {
Console.WriteLine("Error Opening File:\n" + exc.Message);
return ;
}
388
Part I: The C# Language
// Wrap the file stream in a StreamWriter.
StreamWriter fstr_out = new StreamWriter(fout);
try {
Console.WriteLine("Enter text ('stop' to quit).");
do {
Console.Write(": ");
str = Console.ReadLine();
if(str != "stop") {
str = str + "\r\n"; // add newline
fstr_out.Write(str);
}
} while(str != "stop");
} catch(IOException exc) {
Console.WriteLine("I/O Error:\n" + exc.Message);
} finally {
fstr_out.Close();
}
}
}
In some cases, it might be more convenient to open a file directly using StreamWriter.
To do so, use one of these constructors:
StreamWriter(string path)
StreamWriter(string path, bool append)
Here, path. In 
the second form, if append is true, then output is appended to the end of an existing file. 
created. Also, both throw an IOException if an I/O error occurs. Other exceptions are also 
possible.
Here is the key-to-disk program rewritten so it uses StreamWriter to open the output file:
// Open a file using StreamWriter.
using System;
using System.IO;
class KtoD {
static void Main() {
string str;
StreamWriter fstr_out = null;
try {
// Open the file, wrapped in a StreamWriter.
fstr_out = new StreamWriter("test.txt");
Console.WriteLine("Enter text ('stop' to quit).");
do {
Console.Write(": ");
str = Console.ReadLine();
P
A
R
T
I
Chapter 14: Using I/O 
389
P
A
R
T
I
P
A
R
T
I
if(str != "stop") {
str = str + "\r\n"; // add newline
fstr_out.Write(str);
}
} while(str != "stop");
} catch(IOException exc) {
Console.WriteLine("I/O Error:\n" + exc.Message);
} finally {
if(fstr_out != null) fstr_out.Close();
}
}
}
Using a StreamReader
To create a character-based input stream, wrap a byte stream inside a StreamReader.
StreamReader defines several constructors. A frequently used one is shown here:
StreamReader(Stream stream)
Here, stream is the name of an open stream. This constructor throws an 
ArgumentNullException if stream is null. It throws an ArgumentException if stream
is not opened for input. Once created, a StreamReader will automatically handle the 
conversion of bytes to characters. When you are done with the StreamReader, you 
must close it. Closing the StreamReader also closes the underlying stream.
The following program creates a simple disk-to-screen utility that reads a text file called 
test.txt and displays its contents on the screen. Thus, it is the complement of the key-to-disk 
utility shown in the previous section:
// A simple disk-to-screen utility that demonstrates a StreamReader.
using System;
using System.IO;
class DtoS {
static void Main() {
FileStream fin;
string s;
try {
fin = new FileStream("test.txt", FileMode.Open);
}
catch(IOException exc) {
Console.WriteLine("Error Opening file:\n" + exc.Message);
return ;
}
StreamReader fstr_in = new StreamReader(fin);
try {
while((s = fstr_in.ReadLine()) != null) {
Console.WriteLine(s);
}
} catch(IOException exc) {
Console.WriteLine("I/O Error:\n" + exc.Message);
390
Part I: The C# Language
} finally {
fstr_in.Close();
}
}
}
In the program, notice how the end of the file is determined. When the reference returned 
byReadLine( ) is null, the end of the file has been reached. Although this approach works, 
StreamReader provides an alternative means of detecting the end of the stream: the 
EndOfStream property. This read-only property is true when the end of the stream has been 
reached and false otherwise. Therefore, you can use EndOfStream to watch for the end of a 
file. For example, here is another way to write the while loop that reads the file:
while(!fstr_in.EndOfStream) {
s = fstr_in.ReadLine();
Console.WriteLine(s);
}
In this case, the use of EndOfStream makes the code a bit easier to understand but does 
not change the overall structure of the sequence. There are times, however, when the use 
ofEndOfStream can simplify an otherwise tricky situation, adding clarity and improving 
structure.
As with StreamWriter, in some cases, you might find it easier to open a file directly 
usingStreamReader. To do so, use this constructor:
StreamReader(string path)
Here, path
The file must exist. If it doesn’t, a FileNotFoundException is thrown. If path is null, then 
anArgumentNullException is thrown. If path is an empty string, ArgumentException is 
thrown. IOException and DirectoryNotFoundException are also possible.
Redirecting the Standard Streams
As mentioned earlier, the standard streams, such as Console.In, can be redirected. By far, 
the most common redirection is to a file. When a standard stream is redirected, input 
and/or output is automatically directed to the new stream, bypassing the default devices. 
By redirecting the standard streams, your program can read commands from a disk file, 
create log files, or even read input from a network connection.
Redirection of the standard streams can be accomplished in two ways. First, when you 
execute a program on the command line, you can use the < and > operators to redirect 
Console.In and/or Console.Out, respectively. For example, given this program:
using System;
class Test {
static void Main() {
Console.WriteLine("This is a test.");
}
}
P
A
R
T
I
Chapter 14: Using I/O 
391
P
A
R
T
I
P
A
R
T
I
executing the program like this:
Test > log
log. Input can be redirected in 
the same way. The thing to remember when input is redirected is that you must make sure 
that what you specify as an input source contains sufficient input to satisfy the demands of 
the program. If it doesn’t, the program will hang.
The< and > command-line redirection operators are not part of C#, but are provided 
by the operating system. Thus, if your environment supports I/O redirection (as is the case 
with Windows), you can redirect standard input and standard output without making any 
changes to your program. However, there is a second way that you can redirect the standard 
streams that is under program control. To do so, you will use the SetIn( ),SetOut( ), and 
SetError( ) methods, shown here, which are members of Console:
static void SetIn(TextReader newIn)
static void SetOut(TextWriter newOut)
static void SetError(TextWriter newError)
Thus, to redirect input, call SetIn( ), specifying the desired stream. You can use any input 
stream as long as it is derived from TextReader. To redirect output, call SetOut( ), specifying 
the desired output stream, which must be derived from TextWriter. For example, to redirect 
output to a file, specify a FileStream that is wrapped in a StreamWriter. The following 
program shows an example:
// Redirect Console.Out.
using System;
using System.IO;
class Redirect {
static void Main() {
StreamWriter log_out = null;
try {
log_out = new StreamWriter("logfile.txt");
// Redirect standard out to logfile.txt.
Console.SetOut(log_out);
Console.WriteLine("This is the start of the log file.");
for(int i=0; i<10; i++) Console.WriteLine(i);
Console.WriteLine("This is the end of the log file.");
} catch(IOException exc) {
Console.WriteLine("I/O Error\n" + exc.Message);
} finally {
if(log_out != null) log_out.Close();
}
}
}
392
Part I: The C# Language
When you run this program, you won’t see any of the output on the screen, but the file 
logfile.txt will contain the following:
This is the start of the log file.
0
1
2
3
4
5
6
7
8
9
This is the end of the log file.
On your own, you might want to experiment with redirecting the other built-in streams.
Reading and Writing Binary Data
So far, we have just been reading and writing bytes or characters, but it is possible—indeed, 
common—to read and write other types of data. For example, you might want to create a 
file that contains ints,doubles, or shorts. To read and write binary values of the C# built-in 
types, you will use BinaryReader and BinaryWriter. When using these streams, it is important 
to understand that this data is read and written using its internal, binary format, not its 
human-readable text form.
BinaryWriter
ABinaryWriter is a wrapper around a byte stream that manages the writing of binary data. 
Its most commonly used constructor is shown here:
BinaryWriter(Stream output)
Here, output is the stream to which data is written. To write output to a file, you can 
use the object created by FileStream for this parameter. If output is null, then 
anArgumentNullException is thrown. If output has not been opened for writing, 
ArgumentException is thrown. When you are done using a BinaryWriter, you must 
close it. Closing a BinaryWriter also closes the underlying stream.
BinaryWriter
shown in Table 14-5. All can throw an IOException. (Other exceptions are also possible.) 
Notice that a string is written using its internal format, which includes a length specifier. 
BinaryWriter also defines the standard Close( ) and Flush( ) methods, which work as 
described earlier.
BinaryReader
ABinaryReader is a wrapper around a byte stream that handles the reading of binary data. 
Its most commonly used constructor is shown here:
BinaryReader(Stream input)
P
A
R
T
I
Chapter 14: Using I/O 
393
P
A
R
T
I
P
A
R
T
I
Here, input is the stream from which data is read. To read from a file, you can use the object 
created by FileStream for this parameter. If input has not been opened for reading or is 
otherwise invalid, ArgumentException is thrown. When you are done with a BinaryReader
you must close it. Closing a BinaryReader also closes the underlying stream.
BinaryReader provides methods for reading all of C#’s simple types. Several commonly 
used methods are shown in Table 14-6. Notice that ReadString( ) reads a string that is stored 
using its internal format, which includes a length specifier. These methods throw an 
IOException if an error occurs. (Other exceptions are also possible.)
BinaryReader also defines three versions of Read( ), which are shown here:
Method
Description
int Read( )
Returns an integer representation of the next 
available character from the invoking input 
stream. Returns –1 when attempting to read at 
the end of the file.
int Read(byte[ ] buffer, int index, int count)
Attempts to read up to count bytes into buffer 
starting at buffer[index], returning the number of 
bytes successfully read. 
int Read(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. 
These methods will throw an IOException on failure. Other exceptions are possible. Also 
defined is the standard Close( ) method.
Method
Description
void Write(sbyte value)
Writes a signed byte.
void Write(byte value)
Writes an unsigned byte.
void Write(byte[ ] buffer)
Writes an array of bytes.
void Write(short value)
Writes a short integer.
void Write(ushort value)
Writes an unsigned short integer.
void Write(int value)
Writes an integer.
void Write(uint value)
Writes an unsigned integer.
void Write(long value)
Writes a long integer.
void Write(ulong value)
Writes an unsigned long integer.
void Write(float value)
Writes a float.
void Write(double value)
Writes a double.
void Write(decimal value)
Writes a decimal.
void Write(char ch)
Writes a character.
void Write(char[ ] chars)
Writes an array of characters.
void Write(string value)
Writes a string using its internal representation, which includes a 
length specifier.
T
ABLE
14-5  Commonly Used Output Methods Defi ned by BinaryWriter
Documents you may be interested
Documents you may be interested