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

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

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 :\. 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.csio1.cs Example: io2.csio2.cs Example: io3.csio3.cs Example: io4.csio4.cs Example: io5.csio5.cs Example: io6.csio6.cs Example: io7.csio7.cs Example: io8.csio8.cs