C# - Working With Files

Working With Files in C#

Introduction to Working With Files in C#

Working with files is one of the most important skills in C# programming. Whether you are building a desktop application, web application, enterprise system, or automation tool, you will frequently need to read data from files, write data to files, manage directories, or process file streams. In .NET, file handling is powerful, secure, and efficient thanks to the classes provided in the System.IO namespace.

This comprehensive guide covers everything you need to know about C# Working With Files, including file creation, reading files, writing files, file streams, directory handling, binary files, exception handling, and best practices. If you are preparing for interviews or building real-world applications, mastering C# File Handling is essential.

Understanding the System.IO Namespace

The System.IO namespace provides classes that allow developers to interact with files and directories. It contains classes such as:

• File
• FileInfo
• Directory
• DirectoryInfo
• FileStream
• StreamReader
• StreamWriter
• BinaryReader
• BinaryWriter
• Path

To use file-related operations in C#, you must include:

using System;
using System.IO;

This namespace provides both simple and advanced file handling capabilities in C# applications.

Creating a File in C#

Creating a file is the first step in many applications. The File class provides static methods to create files.

Using File.Create()

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = "sample.txt";
        File.Create(path);
        Console.WriteLine("File Created Successfully");
    }
}

This method creates a file in the specified location. If the file already exists, it overwrites it.

Using FileStream to Create a File

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = "data.txt";
        using (FileStream fs = new FileStream(path, FileMode.Create))
        {
            Console.WriteLine("File created using FileStream.");
        }
    }
}

C# FileStream is used when you need more control over file operations.

Writing Data to a File in C#

Writing data to files is a core concept in C# Read and Write Files operations.

Using File.WriteAllText()

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = "example.txt";
        string content = "Welcome to C# File Handling.";
        File.WriteAllText(path, content);
    }
}

Using File.WriteAllLines()

string[] lines = { "Line 1", "Line 2", "Line 3" };
File.WriteAllLines("lines.txt", lines);

Using StreamWriter

using (StreamWriter sw = new StreamWriter("stream.txt"))
{
    sw.WriteLine("This is written using StreamWriter.");
}

StreamWriter provides better flexibility for writing large amounts of data.

Reading Data from a File in C#

Reading files is equally important in File Handling in C#.

Using File.ReadAllText()

string content = File.ReadAllText("example.txt");
Console.WriteLine(content);

Using File.ReadAllLines()

string[] lines = File.ReadAllLines("lines.txt");
foreach (string line in lines)
{
    Console.WriteLine(line);
}

Using StreamReader

using (StreamReader sr = new StreamReader("stream.txt"))
{
    string line;
    while ((line = sr.ReadLine()) != null)
    {
        Console.WriteLine(line);
    }
}

StreamReader is ideal for reading large files line by line.

Appending Data to a File

Sometimes, instead of overwriting, you need to append data.

File.AppendAllText("example.txt", "\nNew appended line.");

Or using StreamWriter:

using (StreamWriter sw = new StreamWriter("example.txt", true))
{
    sw.WriteLine("Appending using StreamWriter.");
}

Working With FileStream in C#

C# FileStream provides low-level file access and is useful when working with byte data.

using (FileStream fs = new FileStream("binary.dat", FileMode.Create))
{
    byte[] data = new byte[] { 65, 66, 67 };
    fs.Write(data, 0, data.Length);
}

FileStream supports different FileMode options:

• Create
• Open
• Append
• CreateNew
• Truncate

Working With Binary Files

Binary files store data in binary format rather than text format.

Writing Binary Data

using (BinaryWriter bw = new BinaryWriter(File.Open("data.bin", FileMode.Create)))
{
    bw.Write(100);
    bw.Write("C# Binary Data");
}

Reading Binary Data

using (BinaryReader br = new BinaryReader(File.Open("data.bin", FileMode.Open)))
{
    int number = br.ReadInt32();
    string text = br.ReadString();
    Console.WriteLine(number + " " + text);
}

Working With Directories in C#

Directory management is part of C# Working With Files.

Create Directory

Directory.CreateDirectory("MyFolder");

Check if Directory Exists

if (Directory.Exists("MyFolder"))
{
    Console.WriteLine("Directory exists.");
}

Get Files in Directory

string[] files = Directory.GetFiles("MyFolder");
foreach (string file in files)
{
    Console.WriteLine(file);
}

File and Directory Information Classes

The FileInfo and DirectoryInfo classes provide instance-based access.

FileInfo fileInfo = new FileInfo("example.txt");
Console.WriteLine("File Name: " + fileInfo.Name);
Console.WriteLine("File Size: " + fileInfo.Length);

DirectoryInfo dirInfo = new DirectoryInfo("MyFolder");
Console.WriteLine("Directory Name: " + dirInfo.Name);

Exception Handling in File Operations

File operations can throw exceptions such as:

• FileNotFoundException
• DirectoryNotFoundException
• IOException
• UnauthorizedAccessException

try
{
    string content = File.ReadAllText("missing.txt");
}
catch (FileNotFoundException ex)
{
    Console.WriteLine("File not found: " + ex.Message);
}

Proper exception handling ensures robust applications.

Path Class in C#

The Path class helps manipulate file and directory paths.

string filePath = @"C:\Files\example.txt";
Console.WriteLine(Path.GetFileName(filePath));
Console.WriteLine(Path.GetExtension(filePath));
Console.WriteLine(Path.GetDirectoryName(filePath));

Asynchronous File Operations in C#

For better performance, use async methods.

using System.Threading.Tasks;

static async Task WriteFileAsync()
{
    await File.WriteAllTextAsync("async.txt", "Async File Write in C#");
}

Async programming improves scalability in modern .NET applications.

Real-World Applications of C# Working With Files

• Log file creation
• Data storage and retrieval
• Configuration management
• Report generation
• Backup and restore systems

Mastering C# File Handling helps developers build scalable, secure, and high-performance applications.

C# Working With Files is a fundamental skill for every .NET developer. From basic file creation to advanced binary file handling and asynchronous operations, the System.IO namespace provides comprehensive tools for managing files and directories efficiently.

Understanding concepts like C# Read and Write Files, C# FileStream, directory management, and exception handling ensures you can build real-world applications with confidence. Practice regularly and implement file operations in mini projects to strengthen your understanding.