Ajay Tripathi

Input Output

Ajay Tripathi

Input/output (IO) refers to the operations for reading and writing data to streams and files.

In the .NET Framework, you use the classes in the System.IO namespace to perform these operations.

The System.IO namespace provides a number of classes that can be roughly grouped into three categories:

Classes for reading and writing bytes. Classes for reading and writing characters. Classes for reading and writing binary data. In the first group classes are derived from the Stream class. In the second category we have reader and writer classes, such as

StreamReader and StreamBuffer. The third group includes classes such as BinaryReader and

BinaryWriter. Which class you should use for your input and output operations will

depend on the kind of data you are going to work with.

Ajay Tripathi

The File Class Use the File class to manipulate a file; to create, copy, or delete it, and

check if it exists. Also use it to open a file for reading and writing. To read from and write to a file itself, however, you need to use other

classes, such as the FileStream or the BufferedStream class. The File class constructor is private, so you cannot instantiate a file

using the new keyword. This is not necessary because all methods of the File class are static. These static methods perform security checks every time they are

called. If you need to access the same file frequently, use the FileInfo class

instead. The following is the list of the most important methods of the File class:

Ajay Tripathi

Create Creates a file in a specified directory. You call this method passing a file path or a file path

and an integer of a buffer size for the resulting FileStream object.

For example, the following code creates a file called newFile.txt in the C:\data directory, returns a FileStream, and then closes the FileStream object straight away:

FileStream fs = File.Create("C:/data/newFile.txt"); fs.Close();

Ajay Tripathi

the following code creates a FileStream with a buffer size of 16KB.

FileStream fs = File.Create(" C:/data/newFile.txt", 16384);

If the file c:\data\newfile.txt already exists, it will be overwritten.

Ajay Tripathi

CreateText Creates a file and returns a StreamWriter object that

you can use to write text into that file. Like Create, you pass a file path to the method, and

any existing file will be overwritten. For example: StreamWriter sw = File.CreateText(" C:/data/new.txt");

Ajay Tripathi

AppendText Returns a StreamWriter object to a specified

existing file. The text you write will then be appended to

the end of the file. If the file does not exist, AppendText will

create a new file. You pass a file path to this method.

Ajay Tripathi

Exists Returns true if a file in a specified path exists;

otherwise, it returns false. Its only parameter is a path and filename.

Ajay Tripathi

Copy Copies a file to another folder. There are two overloads of this

method, as follows: public static void Copy( string sourceFileName, string

destFileName ); public static void Copy( string sourceFileName, string

destFileName, bool overwrite ); The first overload of the method will throw an IOException if the

destination file already exists. So will the second overload, if the overwrite argument is false. For both overloads, a FileNotFoundException will be thrown if

the source file does not exist. In addition, the method can throw an ArgumentException if either

sourceFilename or destinationFilename is invalid.

Ajay Tripathi

Move Moves a file to another directory. The Move method has the same syntax as

the first overload of the Copy method. The difference from the Copy method is that

Move deletes the source file.

Ajay Tripathi

Open Opens a file and returns a FileStream object. If the file to be opened does not exist, a FileNotFoundException

exception is thrown. This method has three overloads, all of which require that you

pass a path and filename as the first argument and a member of the FileMode enumeration as the second.

The second and third overloads require a member of the FileAccess enumeration as their third argument, while the third overload requires a member of the FileShare enumeration as its fourth argument.

Ajay Tripathi

The FileMode enumeration tells the operating system how the file should be opened. Its members are Append, Create, CreateNew, Open, OpenOrCreate, and Truncate.

The FileAccess enumeration indicates to the operating system whether the file is to be opened for reading or writing.

Its members are Read, ReadWrite, and Write. The FileShare enumeration tells the operating system how to

control access to the same opened file from other threads, processes, or users.

Its members are Inheritable, None, Read, ReadWrite, and Write.

If the value of the argument is FileShare.Write, for example, other programs can write to the opened file.

Ajay Tripathi

Ajay Tripathi

OpenRead Opens a file as read-only and returns a FileStream object. Its only parameter is the path and name of the file. OpenText Opens a file and returns a StreamReader object. Its only parameter is the path and name of the file. OpenWrite Opens a file and returns a Stream object. You can use this Stream object to read and write to the file. The method's only parameter is the path and name of the file.

Ajay Tripathi

GetAttributes Obtains the file's attributes, as expressed in a

bitwise combination of the members of the FileAttributes enumeration: Archive, Compressed, Device, Directory, Encrypted, Hidden, Normal, NotContentIndexed, Offline, ReadOnly, ReparsePoint, SparseFile, System, and Temporary.

SetAttributes Changes the attribute of a file. You pass a file path and a bitwise combination of

the members of the FileAttribute enumeration to this method.

Ajay Tripathi

Ajay Tripathi

The FileInfo Class

The File class has static methods that can be conveniently used without having to have an instance of a File object; however, those methods always perform security checks that adversely affect performance.

The FileInfo class provides similar methods for similar tasks, but without security checks.

You should use FileInfo if you are going to access a file several times. Also, unlike File, methods in FileInfo are instance methods. To create a FileInfo object, pass a valid file path to its constructor. The Create method, for example, behaves like the Create method of the

File class. For instance, the following code uses the FileInfo class to create a file: FileInfo fileInfo = new FileInfo("C:/NextGen.txt"); FileStream fs = fileInfo.Create();

Ajay Tripathi

The Directory Class

The Directory class represents a directory. Its constructor is private, so you cannot use the new

keyword to construct a Directory object. That is not necessary, in any case, because all

methods of the Directory class are static. The Directory class performs security checks on all

of its methods, resulting in slightly reduced performance.

If you will be accessing the same directory often, use the DirectoryInfo class instead.

The following are some of the important methods of the Directory class:

Ajay Tripathi

CreateDirectory Creates a directory in the specified path. If the directory's parent does not exist, the parent directory will

also be created. For example, if you pass the path C:\data\projects\RD to this

method and the projects directory does not exist, both the RD and projects directories will be created.

The return value of this method is a DirectoryInfo object representing the created directory.

For example: DirectoryInfo dirInfo = Directory.CreateDirectory("

C:/data/Projects/RD"); System.Console.WriteLine(dirInfo.Name); // prints "RD"

Ajay Tripathi

Delete Deletes an existing directory and, optionally, all of its

subdirectories and files. If the directory does not exist, a DirectoryNotFoundException will

be thrown. This method has two overloads, as follows: public static void Delete(string path); public static void Delete(string path, bool recursive); The first overload allows you to pass an empty directory to

delete. If the directory is not empty, an IOException will be thrown. The second overload enables you to delete a directory and all of

its subdirectories and files, if the recursive argument is set to true.

Ajay Tripathi

Exists Returns true if the specified directory exists; otherwise, it returns false. Its single argument is the path to the directory. GetDirectories Returns an array of strings containing all of the subdirectories of a directory. The first overload is the most straightforward; it accepts a valid path to the

directory, the subdirectories of which you want to obtain. The second overload allows you to specify a pattern as the second argument. For example, with the second overload, you can obtain only subdirectories that

have names beginning with a certain substring, as illustrated by the following code, which prints all of the subdirectories of the C:\ drive that start with the letter W or w:

string[] dirs = Directory.GetDirectories("C:\\", "W*"); int count = dirs.Length; for (int i=0; i<count; i++) System.Console.WriteLine(dirs[i]);

Ajay Tripathi

GetFiles Returns all of the files in a directory. Like the GetDirectories method, this method has two overloads. The first overload returns an array of Strings containing the filenames in

a directory. The second overload allows you to specify a pattern as the second

argument. For example, the following code prints all of the files in the C:\ drive that

start with the letter A or a: string[] files = Directory.GetFiles("C:\\", "A*"); int count = files.Length; for (int i=0; i<count; i++) System.Console.WriteLine(files[i]);

Ajay Tripathi

GetLogicalDrives Returns an array of Strings containing all of the

logical drive names of the current computer in the format <drive_letter>:\.

For example, the following code prints all of the drive names in the computer:

string[] drives = Directory.GetLogicalDrives(); int count = drives.Length; for (int i=0; i<count; i++)

System.Console.WriteLine(drives[i]);

Ajay Tripathi

GetParent Returns a DirectoryInfo object representing the parent directory of the specified

directory. Its single argument is the path of the directory, the parent of which is to be

returned. Move Moves a specified directory and all of its subdirectories and files to a new

location. This method accepts two arguments: the path of the source directory, and the

path to the new location. GetCurrentDirectory Returns a String object containing the full path to the current directory. This method has no parameters. SetCurrentDirectory Sets a new current directory. This method's only argument is the path of the directory to make current.

Ajay Tripathi

The DirectoryInfo Class

The Directory class provides a convenient way of manipulating directories.

The convenience comes at a price, however: the Directory class performs security checks on all of its methods.

If you are going to access the same directory multiple times, you can avoid these security checks by using the DirectoryInfo class, which provides methods similar to those in the Directory class, but with all of its methods instance methods.

Therefore, you must first construct a DirectoryInfo object by passing a path to its constructor, as in the following code:

Ajay Tripathi

DirectoryInfo dirInfo = new DirectoryInfo("C:/data"); Constructing a DirectoryInfo object does not mean creating a directory if

it does not yet exist. To create a directory, you need to call the Create method, as shown in

the following code: DirectoryInfo dirInfo = new DirectoryInfo(" C:/XFiles.txt"); dirInfo.Create(); If the directory already exists, the call to the Create method does not

throw an exception. If, after constructing a DirectoryInfo object representing a non-existent

directory, however, you call other methods that require that the directory exist, a DirectoryNotFoundException will be thrown.

For example, the Delete, GetDirectories, GetFile, and MoveTo methods require the DirectoryInfo object to represent a directory that exists.

Ajay Tripathi

The Path Class

The Path class provides properties and methods that you can use to write portable applications, when your applications need to run on more than one operating system.

As you may be aware, different operating systems have different directory and file naming conventions.

For example, the Windows operating system recognizes the back-slash (\) character as a directory separator.

In Unix or Linux, however, the forward slash (/) character is used to separate a directory from a subdirectory.

By using the Path class, you can write applications that will run on multiple operating systems without changing your code.

For example, the static field DirectorySeparatorChar translates into the directory separator character of the operating system on which the application is run.

Therefore, if you need to access a file called flower.gif in a subdirectory named images, you can specify the following string as a relative path to the file:

string path = "images" + Path.DirectorySeparatorChar + "Flower.gif"; The following list give the other static fields.

Ajay Tripathi

PathSeparator Returns a character that is used to separate paths in the current

operating system. AltDirectorySeparatorChar Returns a character which is the alternate directory separator character

for the current operating system. In Unix or Linux, this character is the back slash (\). In Windows and Macintosh, this character is the forward slash (/). InvalidPathChars Returns an array of characters that cannot be used in a path in the

current operating system. For instance, in Windows, you cannot have a filename that contains an

asterisk or a question mark. You can use this field to verify the validity of a filename entered by the

user.

Ajay Tripathi

The Stream Class

The Stream class is an abstract class that is implemented by BufferedStream, FileStream, MemoryStream, NetworkStream, and CryptoStream.

The two child classes that are frequently used are FileStream and BufferedStream.

Even though you cannot instantiate a Stream object directly, sometimes you obtain a Stream object from a method, such as the OpenFile method of the System.Windows.Forms.OpenFileDialog class.

To improve performance, you might want to wrap the Stream object inside of a BufferedStream object.

Ajay Tripathi

The Stream class provides functionality that enables programmers to manipulate a Stream.

For example, the Length property returns the number of bytes in the Stream object, and the Position property specifies the position of the pointer in the stream.

Three other properties are CanRead, CanWrite, and CanSeek, all of which are self-explanatory.

Among others, the Stream class provides methods for reading and writing.

When a read or write operation is performed, the position of the Stream is advanced by the number of bytes read or written.

The following are some of the more important methods of the Stream class.

Ajay Tripathi

Close Closes the Stream object and frees all of the

resources it consumes. Even though unused resources will eventually be

garbage collected, it is good programming practice to always call this method when you no longer need a Stream object.

Flush Forces the contents of the buffer to be written to the

underlying device. For example, in a FileStream, this method writes the

buffer to the file.

Ajay Tripathi

Read This method returns an Integer that indicates the number of bytes read. If the pointer is at the end of the stream when Read is called, the

method will return zero. The method has the following signature: public abstract int Read( byte[] buffer, int offset, int count ) The bytes read will be placed in the buffer. You can specify the maximum number of bytes that can be read in

count. If count is greater than the number of available bytes, only the available

bytes will be returned. The offset argument specifies the number of bytes that need to be

skipped before starting to read. If you specify 0 for offset, the read operation will start from the byte

pointed to by the stream pointer.

Ajay Tripathi

ReadByte This method reads one byte and casts it into

an integer, which is returned by the method. If the end of the stream has been reached

when this method is called, a -1 is returned. The method has no parameters.

Ajay Tripathi

Write This method writes an array of bytes into the stream. It does not return any value, and has the following signature: public abstract void Write( byte[] buffer, int offset, int count ) The Write method writes the buffer byte array into the stream. It will write the number of bytes specified by count and skip the

offset number of bytes in buffer before starting the write operation.

Note that count must not be greater than the number of available bytes in the buffer.

WriteByte Writes a single byte to the stream. This method accepts a byte as its argument and does not return

a value.

Ajay Tripathi

The FileStream Class

The FileStream class represents a stream that wraps a file.

You use FileStream for reading and writing bytes of a file.

The FileStream class uses buffering to improve performance.

The easiest way to construct a FileStream object is to use one of its constructors, which accepts a file path and a value from the FileMode enumeration as arguments.

Ajay Tripathi

For instance, the following code creates a file called newFile.txt and writes two bytes into it.

If the file already exists, the file will be overwritten: FileStream fs = new FileStream("C:/newFile.txt",

FileMode.Create); Byte[] bytes = new Byte[2]; bytes[0] = 65; bytes[1] = 66; fs.Write(bytes, 0, 2); fs.Close();

Ajay Tripathi

Some methods return a FileStream object without requiring that you create it with one of its constructors.

For example, the following code uses the File class Create method to create a file called newFile.txt, returns a FileStream object, and then writes two bytes to the file:

FileStream fs = File.Create("C:/newFile2.txt"); Byte[] bytes = new Byte[2]; bytes[0] = 65; bytes[1] = 66; fs.Write(bytes, 0, 2); fs.Close();

Ajay Tripathi

If you want to append to a file instead of creating a new one, you must use the FileStream constructor that accepts a FileMode and a FileAccess value, and you must specify FileAccess.Write for the file access type, as shown in the following code:

FileStream fs = new FileStream("C:/newFile.txt", FileMode.Append, FileAccess.Write);

To read from a file, you can use FileMode.Open as the file mode argument in one of the FileStream class constructors.

The following code, for instance, reads two bytes from the newFile.txt file:

FileStream fs = new FileStream("C:/newFile.txt", FileMode.Open); Byte[] bytes = new Byte[2];

int i = fs.Read(bytes, 0, 2); fs.Close ();

Ajay Tripathi

The BufferedStream Class

The BufferedStream class is used to wrap a Stream object and supports buffering to improve performance.

There are two constructors that you can use to create a BufferedStream object.

The first one accepts a Stream object. The BufferedStream object constructed using this

constructor has a buffer size of 4,096 bytes. The second constructor accepts a Stream object as

well as an Integer specifying the size of the buffer, allowing you to set your own buffer size.

Ajay Tripathi

As an example of how to use the BufferedStream, consider the following code, which wraps the Stream object returned from an OpenFileDialog in a BufferedStream object and reads the first 128 bytes of the selected file:

OpenFileDialog openFileDialog = new OpenFileDialog(); if (openFileDialog.ShowDialog() == DialogResult.OK) { string filepath = openFileDialog.FileName; // Open the file using the OpenFile method BufferedStream

bufferedStream = new BufferedStream( openFileDialog.OpenFile()); Byte[] bytes = new Byte[128];

bufferedStream.Read(bytes, 0, 128); } Note that the BufferedStream class is derived from the Stream class;

therefore, it inherits all of the Stream class methods and properties.

Ajay Tripathi

The StreamReader Class

The StreamReader class is a child class of TextReader. You use StreamReader and other Reader classes to manipulate text. With this class, you can use the Read method to read one character

each time or a fixed number of characters, or you can use the ReadLine method to read a line of text.

You can construct a StreamReader object from a Stream object returned by a method call, or by specifying a path to a file to one of the StreamReader class constructors.

Optionally, you can also pass an encoding scheme to a constructor to tell the StreamReader object the encoding used in the text file.

If no encoding is supplied, the default encoding (System.Text.UTF8Encoding) is assumed.

The stream's current encoding can be retrieved from the read-only CurrentEncoding property.

Ajay Tripathi

As an example, the following code opens a text file named CompanySecret.txt and uses the ReadLine method to print the text one line at a time.

The ReadLine method returns a null reference if it encounters the end of the stream:

StreamReader sr = new StreamReader(" C:/CompanySecret.txt");

string line = sr.ReadLine(); while (line != null) { System.Console.WriteLine(line); line = sr.ReadLine(); } sr.Close();

Ajay Tripathi

The StreamWriter Class

The StreamWriter class is derived from the TextWriter class and can be used to write text to a stream.

You can create an instance of the StreamWriter class by assigning it a Stream object returned by a method call, or by passing a file path to one of its constructors.

Like the StreamReader class, you can also pass an encoding scheme of your choice to one of its constructors.

The most important methods of the StreamWriter class are Write and WriteLine.

Write enables you to write a character, an array of characters, or a string.

The WriteLine method accepts a String and adds an end-of-line character to the end of the string.

Ajay Tripathi

For example, the following code opens a new file called NewCompanySecret.txt and writes a string of text to it:

StreamWriter sw = new StreamWriter(" C:/NewCompanySecret.txt");

string line = "Don't tell anyone!!!"; sw.WriteLine(line);

sw.Close();

Ajay Tripathi

The BinaryReader Class

You use the BinaryReader class to read binary data from a file. You can construct a BinaryReader object by passing its

constructor a Stream object; you can't pass a file path to create a BinaryReader object. Once you have a BinaryReader object, you can use one of its ReadXXX methods to read various types of data.

For example, the ReadByte method is used to read a byte, and the ReadString method is used to read a String.

The data must be read in the order it was written. For example, if you store a byte and then a string to a binary file,

you must first read a byte and then read a String.

Ajay Tripathi

The BinaryReader class also has a Read method, which has three overloads that allow you to read a character, an array of bytes, or an array of characters.

As an example, here is the code that reads a byte and a string from a binary file called MyBinary.bin:

BinaryReader br = new BinaryReader(File.OpenRead(" C:/MyBinary.bin"));

Byte b2 = br.ReadByte(); string s2 = br.ReadString(); System.Console.WriteLine(s2);

System.Console.WriteLine(b2); br.Close();

Ajay Tripathi

The BinaryWriter Class

The BinaryWriter class is used to write binary data to a stream. You can construct a BinaryWriter object by passing a Stream object;

you can’t pass a file path to create a BinaryWriter object. In addition, there is also a parameterless constructor. The BinaryWriter class most important method is Write. This method has 18 overloads that guarantee that you can write any

type of data to a BinaryWriter object. For example, the following code creates a BinaryWriter object that is

linked to a new file called MyBinary.bin, and writes a byte and a string: BinaryWriter bw = new BinaryWriter(File.Create(" C:/MyBinary.bin")); Byte b = 17; string s = "August"; bw.Write(b); bw.Write(s); bw.Close();

Ajay Tripathi

Example: io1.cs Example: io2.cs Example: io3.cs Example: io4.cs Example: io5.cs Example: io6.cs Example: io7.cs Example: io8.cs