C# File I/O Operations: Practical Examples

Introduction to C# File I/O Operations

C# File I/O (Input/Output) operations are essential for managing files within applications. They allow developers to read from and write to files, enabling data persistence and interaction with external data sources. In this article, we will explore three diverse examples of C# File I/O operations that cater to various use cases.

1. Reading Text from a File

Use Case: Configurations or Data Import

In many applications, developers need to read configuration settings or import data from external text files. This example demonstrates how to read text from a file and display its contents.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string filePath = "config.txt";

        try
        {
            string[] lines = File.ReadAllLines(filePath);
            foreach (string line in lines)
            {
                Console.WriteLine(line);
            }
        }
        catch (FileNotFoundException e)
        {
            Console.WriteLine("File not found: " + e.Message);
        }
        catch (Exception e)
        {
            Console.WriteLine("An error occurred: " + e.Message);
        }
    }
}

Notes:

• Ensure the specified file exists in the project directory.
• This method is beneficial for reading settings or data lists.

2. Writing Text to a File

Use Case: Logging or Data Export

Logging application events or exporting data to a file is crucial for tracking and debugging. This example illustrates how to write text to a file.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string filePath = "log.txt";
        string message = "Log entry at " + DateTime.Now.ToString();

        try
        {
            using (StreamWriter writer = new StreamWriter(filePath, true))
            {
                writer.WriteLine(message);
            }
            Console.WriteLine("Log entry added successfully.");
        }
        catch (Exception e)
        {
            Console.WriteLine("An error occurred: " + e.Message);
        }
    }
}

Notes:

• The true parameter in StreamWriter allows appending to the file instead of overwriting it.
• This approach is commonly used for logging application behavior.

3. Serializing and Deserializing Objects to/from a File

Use Case: Data Persistence for Application State

When applications require storing complex data structures, serialization is essential. This example shows how to serialize an object to a file and then deserialize it back.

using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

[Serializable]
class User
{
    public string Name { get; set; }
    public int Age { get; set; }
}

class Program
{
    static void Main()
    {
        string filePath = "user.dat";
        User user = new User { Name = "John Doe", Age = 30 };

        // Serialize the object
        try
        {
            using (FileStream stream = new FileStream(filePath, FileMode.Create))
            {
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(stream, user);
            }
            Console.WriteLine("User serialized successfully.");
        }
        catch (Exception e)
        {
            Console.WriteLine("Serialization error: " + e.Message);
        }

        // Deserialize the object
        try
        {
            using (FileStream stream = new FileStream(filePath, FileMode.Open))
            {
                BinaryFormatter formatter = new BinaryFormatter();
                User deserializedUser = (User)formatter.Deserialize(stream);
                Console.WriteLine($"Name: {deserializedUser.Name}, Age: {deserializedUser.Age}");
            }
        }
        catch (Exception e)
        {
            Console.WriteLine("Deserialization error: " + e.Message);
        }
    }
}

Notes:

• The [Serializable] attribute is necessary for classes to be serialized.
• This method is useful for saving the state of an object between application sessions.

By mastering these C# File I/O operations, developers can effectively manage data in their applications, ensuring a smoother user experience and robust functionality.