File Input and Output

Let's try to access and read a file present in the disk. For this, you need to create a new file called "example.txt" in your drive. For now, manually edit this file and write "Hello World" and save the file. To access and read this file programmatically in C#, we can write the following code.

using System;
using System.IO;
using System.Text;

class Program 
{
  static void Main(string[] args)
  {
    Console.WriteLine("FileStream");
	Console.WriteLine();

    FileStream fs = new FileStream("example.txt", FileMode.Open);
    byte[] readBytes = new byte[128];

    fs.Read(readBytes, 0, readBytes.Length);

    fs.Close();

    Console.WriteLine(Encoding.ASCII.GetString(readBytes));

    Console.Write("Press any key to continue...");
	Console.ReadKey(true);
  }
}
			

In the above program, we have created an instance of FileStream by providing a file path and the FileMode as "Open". To read the contents from the file, we simply used its "Read(...)" method which takes a buffer as a byte array and it stores the contents in that array. We need to call the Close() method to release the file after we are all done using it. In the end, we are simply printing the contents from the byte array. The "Encoding" class provides us with various options to convert bytes array to string data type. The program will output "Hello World" to the console.

Important Note : Every time we are using the Streams, we need to call the Close() method to release our resources. This sometimes gives an additional overhead to make sure we don't miss it in our program. Luckily, there is an alternative to it. Every stream class implements the "IDisposable" interface. The Close() method internally does some stuff and calls the dispose method. In C#, however, we can use the "using" keyword to define a set of blocks. As soon as this block completes its execution the CLR automatically invokes the "Dispose" method of the object provided within the using construct. Let's convert the above example and use the "using" keyword so that we don't have to worry about calling the Close() method every time.

static void Main(string[] args)
{
	Console.WriteLine("FileStream");
	Console.WriteLine();

	byte[] readBytes = new byte[128];
	using(FileStream fs = new FileStream("example.txt", FileMode.Open))
	{
		fs.Read(readBytes, 0, readBytes.Length);
	}

	Console.WriteLine(Encoding.ASCII.GetString(readBytes));

	Console.Write("Press any key to continue...");
	Console.ReadKey(true);
}
			

Going forward we will use the "using" keyword for all our stream operations.

The "Write(...)" method of the FileStream object is used to write contents in a file. Let's see more in the below example.

using System;
using System.IO;
using System.Text;

class Program 
{
  static void Main(string[] args)
  {
    Console.WriteLine("FileStream");
		Console.WriteLine();

    var encoder = new UnicodeEncoding();

    byte[] writeBytes = encoder.GetBytes("FileStream write example.");
    using(FileStream fs = new FileStream("example.txt", FileMode.Create, FileAccess.Write))
    {
      fs.Write(writeBytes, 0, writeBytes.Length);
    }

    Console.WriteLine("Contents have been written. Check the file.");

    Console.Write("Press any key to continue...");
		Console.ReadKey(true);
  }
}
			

In the above example, first, we are using a text encoder that converts a string into a byte array. Notice that we have specified FileMode as "Create" and FIleAccess as "Write". Then, we are calling the Write(...) method of the FileStream object. After the program finishes execution, you can check out the file "example.txt" and verify the text written.

Next we will learn about "MemoryStream" class.

These are used to read and write primitive data types such as int, float, double as bytes. Let's see BinaryReader and BinaryWriter with an example.

using System;
using System.IO;
using System.Text;

class Program 
{
  static void Main(string[] args)
  {
    Console.WriteLine("Binary Reader and Writer");
	Console.WriteLine();

    // Let's write some content
    using(var bw = new BinaryWriter(new FileStream("brw.txt", FileMode.Append)))
    {
		bw.Write(24.005);
		bw.Write("Hello World");
		bw.Write('a');
		bw.Write(23.450009876f);
    }

    using(var br = new BinaryReader(new FileStream("brw.txt", FileMode.Open)))
    {
		Console.WriteLine(br.ReadDouble());
		Console.WriteLine(br.ReadString());
		Console.WriteLine(br.ReadChar());
		Console.WriteLine(br.ReadSingle());
    }

    Console.Write("Press any key to continue...");
	Console.ReadKey(true);
  }
}
			

In the above example, you can see that the constructors of both BinaryReader and BinaryWriter classes take a stream instance as a parameter (FileStream in this case). First, we have used BinaryWriter's instance to write a few values to the file. These values are C# primitive data types. It provides a Write(..) method with several overloads with primitive types as arguments.

In the next part, we have opened the same file and start reading the content then we have written it into the file created earlier. Please note that sequence matters here. This means that the sequence in which we have written the primitive data types must be read in the same sequence.

The thing to note here is that the text that is written onto the file is in binary format and not human readable.

The StreamReader and StreamWriter classes act as a wrapper on the top of Stream and provide us with a seamless character based reading and writing. The difference between BinaryReader and BinaryWriter is that the content written by StreamReader and StreamWriter is human readable. Let's see an example.

using System;
using System.IO;
using System.Text;

class Program 
{
  static void Main(string[] args)
  {
    Console.WriteLine("Stream Reader and Writer");
		Console.WriteLine();

    using(var sw = new StreamWriter(new FileStream("srw.txt", FileMode.Append)))
    {
      sw.WriteLine("Document");
      sw.Write("Version -");
      sw.WriteLine(4.0);
      sw.WriteLine("-----------------");
      sw.WriteLine("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.");
      sw.WriteLine("Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.");
    }

    using(var sr = new StreamReader(new FileStream("srw.txt", FileMode.Open)))
    {
      Console.WriteLine(sr.ReadToEnd());
    }

    Console.Write("Press any key to continue...");
		Console.ReadKey(true);
  }
}
			

Similar to the previous example, we have defined the FileStream class as the underlying stream for StreamReader and StreamWriter. Using StreamReader's WriteLine(..) method write strings and other data types as well. The StreamReader class is used to read the text-based contents from a file. In this case, we are reading a similar file that we wrote using the ReadToEnd(..) method of the StreamReader class.

These classes are specially designed for large strings reading and writing. The StringReader class implements the abstract class TextReader and StringWriter class implements the abstract class TextWriter. Their main difference from other reader and writer classes is that under the hood the information is stored in StringBuilder class. The StringBuilder class is designed for heavy string manipulation with optimization. One use case of these classes is to read and write log files which are text extensive files.

The "File" class is a static class and we can perform many operations like file open, create, delete, copy, move, rename, etc. Here are some of the commonly used methods provided by the "File" class.

Apart from these frequently used methods, the File class provides methods for instant text reading and writing like ReadAllText(..), ReadLines(..), WriteAllText(..), etc to quickly read and write the text without operating with streams.

Let's see these operations with an example.

using System;
using System.IO;
using System.Text;

class Program 
{
  static void Main(string[] args)
  {
    Console.WriteLine("File class");
		Console.WriteLine();

    Console.WriteLine("--- Creating a file ---");
    using(var fs = File.Create("file_example_1.txt"))
    {
      var encoder = new UnicodeEncoding();
      byte[] writeBytes = encoder.GetBytes("FileStream write example.");
      fs.Write(writeBytes, 0, writeBytes.Length);
    }

    Console.WriteLine("A new file is created.");

    Console.WriteLine("Opening and reading the created file");
    using(var fs = File.Open("file_example_1.txt", FileMode.Open))
    {
      byte[] readBytes = new byte[128];
      fs.Read(readBytes, 0, readBytes.Length);
      Console.WriteLine(Encoding.ASCII.GetString(readBytes));
    }

    Console.WriteLine("--- Checking if the file exists or not ---");
    Console.WriteLine(File.Exists("file_example_1.txt")? "File exists." : "File does not exists.");

    Console.WriteLine("--- Copying the file with another name ---");
    File.Copy("file_example_1.txt", "file_example_1_copy.txt");

    Console.WriteLine("--- Checking again if the copied file exists or not ---");
    Console.WriteLine(File.Exists("file_example_1_copy.txt")? "File exists." : "File does not exists.");

    Console.WriteLine("--- Deleting the file ---");
    File.Delete("file_example_1.txt");

    Console.WriteLine("--- Checking again if the file exists or not ---");
    Console.WriteLine(File.Exists("file_example_1.txt")? "File exists." : "File does not exists.");

    Console.Write("Press any key to continue...");
		Console.ReadKey(true);
  }
}
			

The "Directory" class is also a static class that allows us to do the operations on the directories or folders present in device. Some of the commonly used Directory operations are.

Let's see some of these Directory class operations with an example.

using System;
using System.IO;
using System.Text;

class Program 
{
  static void Main(string[] args)
  {
    Console.WriteLine("Directory class");
		Console.WriteLine();

    Console.WriteLine("--- Creating a directory ---");
    Directory.CreateDirectory("Directory example");
    Console.WriteLine("--- Directory created ---");

    Console.WriteLine("--- Checking if the directory exists or not ---");
    Console.WriteLine(Directory.Exists("Directory example")? "Directory exists." : "Directory does not exists.");

    Console.WriteLine("--- Deleting the directory ---");
    Directory.Delete("Directory example");
    Console.WriteLine("--- Directory deleted ---");

    Console.WriteLine("--- Checking again if the directory exists or not ---");
    Console.WriteLine(Directory.Exists("Directory example")? "Directory exists." : "Directory does not exists.");

    Console.Write("Press any key to continue...");
		Console.ReadKey(true);
  }
}