C# - Write To a File and Read It

C# - Write To a File and Read It 

Introduction to File Handling in C#

File handling in C# is one of the most important concepts in .NET application development. Whether you are building a console application, Windows Forms app, WPF application, ASP.NET Core web application, or enterprise-level software, reading and writing files is a fundamental requirement.

In this detailed guide, we will explore how to write to a file in C# and read from a file in C# using various classes available in the .NET framework. You will learn about the File class, StreamWriter, StreamReader, FileStream, file modes, exception handling, and best practices.

This tutorial focuses on practical implementation and real-world scenarios. By the end, you will have strong knowledge of:

• C# file handling
• Write text file in C#
• Read text file in C#
• FileStream in C#
• StreamWriter and StreamReader in C#
• File operations in .NET

Why File Handling is Important in C#

File handling allows applications to:

• Store data permanently
• Read configuration files
• Log application events
• Export reports
• Import external data
• Maintain user data

Without file input and output (I/O), applications would lose all data once they stop running. Therefore, understanding C# file I/O is essential for every developer.

Namespaces Required for File Operations

To perform file operations in C#, you must include the following namespace:

using System;
using System.IO;

The System.IO namespace provides classes for file and stream operations.

Primary Classes Used in File Handling

1. File Class

The File class provides static methods for creating, copying, deleting, reading, and writing files.

2. FileStream Class

Used for reading and writing bytes to files.

3. StreamWriter Class

Used for writing text to files.

4. StreamReader Class

Used for reading text from files.

How to Write to a File in C#

Method 1: Using File.WriteAllText()

This is the simplest way to write text into a file in C#. If the file does not exist, it will be created. If it exists, it will overwrite the content.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = "example.txt";
        string content = "Hello, this is C# file writing example.";

        File.WriteAllText(path, content);

        Console.WriteLine("File written successfully.");
    }
}

This method is ideal for small files and quick operations.

Method 2: Using File.WriteAllLines()

Used when writing multiple lines at once.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = "example.txt";
        string[] lines = {
            "First Line",
            "Second Line",
            "Third Line"
        };

        File.WriteAllLines(path, lines);

        Console.WriteLine("Lines written successfully.");
    }
}

Method 3: Using StreamWriter

StreamWriter gives more control over writing operations.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = "example.txt";

        using (StreamWriter writer = new StreamWriter(path))
        {
            writer.WriteLine("Welcome to C# File Handling");
            writer.WriteLine("StreamWriter Example");
        }

        Console.WriteLine("File written using StreamWriter.");
    }
}

The using statement ensures proper resource management by closing the stream automatically.

How to Append Data to a File in C#

Appending means adding data to an existing file without deleting previous content.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = "example.txt";

        using (StreamWriter writer = new StreamWriter(path, true))
        {
            writer.WriteLine("This line is appended.");
        }

        Console.WriteLine("Data appended successfully.");
    }
}

The second parameter set to true enables append mode.

How to Read a File in C#

Method 1: Using File.ReadAllText()

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = "example.txt";

        string content = File.ReadAllText(path);

        Console.WriteLine(content);
    }
}

This reads the entire file content as a single string.

Method 2: Using File.ReadAllLines()

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = "example.txt";

        string[] lines = File.ReadAllLines(path);

        foreach (string line in lines)
        {
            Console.WriteLine(line);
        }
    }
}

Method 3: Using StreamReader

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = "example.txt";

        using (StreamReader reader = new StreamReader(path))
        {
            string line;
            while ((line = reader.ReadLine()) != null)
            {
                Console.WriteLine(line);
            }
        }
    }
}

StreamReader is efficient for large files.

Using FileStream in C#

FileStream provides low-level file access for reading and writing bytes.

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

class Program
{
    static void Main()
    {
        string path = "example.txt";

        using (FileStream fs = new FileStream(path, FileMode.Create))
        {
            byte[] data = Encoding.UTF8.GetBytes("FileStream Example");
            fs.Write(data, 0, data.Length);
        }

        Console.WriteLine("File written using FileStream.");
    }
}

Understanding FileMode in C#

FileMode defines how a file should be opened:

• Create
• CreateNew
• Open
• OpenOrCreate
• Append
• Truncate

Choosing the correct FileMode ensures safe file operations.

Exception Handling in File Operations

File operations may throw exceptions such as:

• FileNotFoundException
• UnauthorizedAccessException
• IOException

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

Always use try-catch blocks in production applications.

Asynchronous File Operations in C#

Async file operations improve performance in large applications.

using System;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        string path = "example.txt";
        await File.WriteAllTextAsync(path, "Async File Writing Example");

        string content = await File.ReadAllTextAsync(path);
        Console.WriteLine(content);
    }
}

Async methods prevent UI blocking in desktop and web applications.

Real-World Use Cases of File Handling

• Logging system errors
• Saving user preferences
• Exporting CSV reports
• Importing data files
• Storing configuration settings
• Backup and restore systems

Difference Between StreamWriter and File.WriteAllText

Understanding how to write to a file and read it in C# is essential for every .NET developer. Whether using File class methods for simple operations or StreamWriter and FileStream for advanced scenarios, C# provides powerful tools for file handling.

Mastering C# file I/O operations will help you build reliable applications capable of storing and retrieving data efficiently. Practice these examples and experiment with different file modes and stream techniques to strengthen your knowledge.