What are I/O classes in C#?

The System.IO namespace in C# provides a comprehensive collection of classes for performing input/output operations. These classes enable you to work with files, directories, streams, and other data sources efficiently.

I/O classes in C# are categorized into several groups based on their functionality −

File and Directory Classes

These classes provide static methods for basic file and directory operations −

using System;
using System.IO;

class Program {
   public static void Main() {
      // File class example
      string fileName = "example.txt";
      File.WriteAllText(fileName, "Hello, World!");
      string content = File.ReadAllText(fileName);
      Console.WriteLine("File content: " + content);
      
      // Directory class example
      string dirName = "TestDirectory";
      Directory.CreateDirectory(dirName);
      Console.WriteLine("Directory created: " + Directory.Exists(dirName));
      
      // Cleanup
      File.Delete(fileName);
      Directory.Delete(dirName);
   }
}

The output of the above code is −

File content: Hello, World!
Directory created: True

Stream Classes

Stream classes provide sequential access to data. FileStream is commonly used for file operations −

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

class Program {
   public static void Main() {
      string fileName = "stream_example.txt";
      byte[] data = Encoding.UTF8.GetBytes("Stream writing example");
      
      // Writing using FileStream
      using (FileStream fs = new FileStream(fileName, FileMode.Create)) {
         fs.Write(data, 0, data.Length);
      }
      
      // Reading using FileStream
      using (FileStream fs = new FileStream(fileName, FileMode.Open)) {
         byte[] buffer = new byte[fs.Length];
         fs.Read(buffer, 0, (int)fs.Length);
         string result = Encoding.UTF8.GetString(buffer);
         Console.WriteLine("Read from stream: " + result);
      }
      
      // Cleanup
      File.Delete(fileName);
   }
}

The output of the above code is −

Read from stream: Stream writing example

Reader and Writer Classes

StreamReader and StreamWriter provide convenient text-based I/O operations −

using System;
using System.IO;

class Program {
   public static void Main() {
      string fileName = "text_example.txt";
      
      // Writing using StreamWriter
      using (StreamWriter writer = new StreamWriter(fileName)) {
         writer.WriteLine("First line");
         writer.WriteLine("Second line");
         writer.WriteLine("Third line");
      }
      
      // Reading using StreamReader
      using (StreamReader reader = new StreamReader(fileName)) {
         string line;
         int lineNumber = 1;
         while ((line = reader.ReadLine()) != null) {
            Console.WriteLine($"Line {lineNumber}: {line}");
            lineNumber++;
         }
      }
      
      // Cleanup
      File.Delete(fileName);
   }
}

The output of the above code is −

Line 1: First line
Line 2: Second line
Line 3: Third line

I/O Classes Overview

Using Path Class for Safe File Operations

using System;
using System.IO;

class Program {
   public static void Main() {
      string directory = @"C:\temp";
      string fileName = "sample.txt";
      
      // Combine paths safely
      string fullPath = Path.Combine(directory, fileName);
      Console.WriteLine("Full path: " + fullPath);
      
      // Get file information
      Console.WriteLine("File name: " + Path.GetFileName(fullPath));
      Console.WriteLine("Extension: " + Path.GetExtension(fullPath));
      Console.WriteLine("Directory: " + Path.GetDirectoryName(fullPath));
      Console.WriteLine("File without extension: " + Path.GetFileNameWithoutExtension(fullPath));
   }
}

The output of the above code is −

Full path: C:\temp\sample.txt
File name: sample.txt
Extension: .txt
Directory: C:\temp
File without extension: sample

Conclusion

The System.IO namespace provides essential classes for file and directory operations, stream-based I/O, and text processing. These classes work together to offer both high-level convenience methods and low-level control for all your input/output needs in C# applications.