File Operation in C#

 Stream Input/Output (I/O)

In C#, Stream Input/Output (I/O) refers to the mechanism for reading from and w

riting to streams of data. Streams are a fundamental concept in C# that provide a uniform way of accessing different types of data, such as files, network sockets, memory, and more.

 

The `System.IO` namespace in C# provides classes and methods for working with streams. There are two main types of streams: input streams (used for reading data) and output streams (used for writing data).

 

To perform Stream I/O in C#, you typically follow these steps:

 

1.      Open the Stream:

Create an instance of a specific stream class, such as `FileStream`, `MemoryStream`, or `NetworkStream`. This step usually involves providing the necessary parameters, such as the file path or network connection details.

 

2.      Read or Write Data:

 

Use the methods provided by the stream class to read or write data. Common methods for reading include `Read`, `ReadAsync`, `ReadByte`, and `ReadLine`, while common methods for writing include `Write`, `WriteAsync`, and `WriteLine`. These methods handle the actual reading from or writing to the underlying data source.

 

3.      Close the Stream:

After you finish reading from or writing to the stream, it's important to close it using the `Close` or `Dispose` method. This step ensures that any resources associated with the stream are properly released.

 

Here's an example that demonstrates reading and writing to a file using Stream I/O in C#:

using System;
using System.IO;

class Program
{
    static void Main()
    {
        // Specify the file path
        string filePath = "example.txt";

        // Open the file stream for writing
        using (FileStream fileStream = new FileStream(filePath, FileMode.Create))
        {
            // Write data to the file
            byte[] data = { 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100 };
            fileStream.Write(data, 0, data.Length);
        }

        // Open the file stream for reading
        using (FileStream fileStream = new FileStream(filePath, FileMode.Open))
        {
            // Read data from the file
            byte[] buffer = new byte[1024];
            int bytesRead = fileStream.Read(buffer, 0, buffer.Length);

            // Convert the read bytes to a string
            string content = System.Text.Encoding.ASCII.GetString(buffer, 0, bytesRead);

            // Display the content
            Console.WriteLine(content);
        }

        // Close the stream automatically using 'using' statement
    }
}

In this example, the program first opens a `FileStream` in write mode and writes the byte array `data` to the file. Then, it opens the same file in read mode, reads the data into a byte array `buffer`, converts it to a string using `System.Text.Encoding.ASCII.GetString`, and displays the content.

 

Note that the `using` statement is used to automatically close the stream when it goes out of scope, ensuring proper cleanup.

 

Stream I/O in C# is a powerful mechanism for working with various data sources and enables you to read and write data in a flexible and efficient manner.

 

File system in C#

Working with the file system in C# involves performing various operations on files and directories, such as creating, reading, writing, deleting, and manipulating them. The .NET framework provides a rich set of classes and methods to work with the file system, primarily within the System.IO namespace.

 

Here's an example that demonstrates some common file system operations:

using System;
using System.IO;

class Program
{
    static void Main()
    {
        // Specify the file path
        string filePath = @"C:\Example\file.txt";

        // Check if the file exists
        if (File.Exists(filePath))
        {
            // Read the contents of the file
            string content = File.ReadAllText(filePath);
            Console.WriteLine("File content:");
            Console.WriteLine(content);
        }
        else
        {
            Console.WriteLine("File does not exist.");
        }

        // Create a new directory
        string directoryPath = @"C:\Example\NewDirectory";
        Directory.CreateDirectory(directoryPath);
        Console.WriteLine("New directory created.");

        // Create a new file and write content to it
        string newFilePath = Path.Combine(directoryPath, "newfile.txt");
        string fileContent = "This is a new file.";
        File.WriteAllText(newFilePath, fileContent);
        Console.WriteLine("New file created and content written.");

        // List all files in a directory
        string[] files = Directory.GetFiles(directoryPath);
        Console.WriteLine("Files in the directory:");
        foreach (string file in files)
        {
            Console.WriteLine(file);
        }

        // Delete a file
        File.Delete(newFilePath);
        Console.WriteLine("File deleted.");

        // Delete a directory
        Directory.Delete(directoryPath);
        Console.WriteLine("Directory deleted.");
    }
}

In this example, we perform the following operations:

 

1. Check if a file exists and read its contents using `File.Exists` and `File.ReadAllText`.

2. Create a new directory using `Directory.CreateDirectory`.

3. Create a new file in the directory and write content to it using `File.WriteAllText`.

4. List all files in the directory using `Directory.GetFiles`.

5. Delete a file using `File.Delete`.

6. Delete a directory using `Directory.Delete`.

 

It's important to handle exceptions when working with the file system to handle cases like file not found, permission issues, etc. You can use try-catch blocks to handle specific exceptions or use methods like `File.Exists` to check for file existence before performing operations.

 

Remember to include the `System.IO` namespace at the beginning of your code to access the file system-related classes and methods.

 

Access File using FileInfo Class

The `FileInfo` class in C# provides a convenient way to access and manipulate files. It is part of the `System.IO` namespace and offers various methods and properties to work with file information.

 

To access a file using the `FileInfo` class, you need to follow these steps:

 

1. Create an instance of the `FileInfo` class, passing the file path as a parameter to the constructor. For example:

FileInfo fileInfo = new FileInfo("C:\\path\\to\\file.txt");

2. Once you have the `FileInfo` object, you can access various properties and methods to work with the file. Here are some commonly used ones:

 

- `Name`: Gets the name of the file.

- `FullName`: Gets the full path of the file.

- `Directory`: Gets the parent directory of the file.

- `Exists`: Checks if the file exists.

- `Length`: Gets the size of the file in bytes.

- `LastWriteTime`: Gets the last write time of the file.

 

Here's an example that demonstrates how to access a file using the `FileInfo` class:

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string filePath = "C:\\path\\to\\file.txt";
        FileInfo fileInfo = new FileInfo(filePath);

        if (fileInfo.Exists)
        {
            Console.WriteLine("File Name: " + fileInfo.Name);
            Console.WriteLine("File Path: " + fileInfo.FullName);
            Console.WriteLine("Directory: " + fileInfo.Directory.FullName);
            Console.WriteLine("File Size: " + fileInfo.Length + " bytes");
            Console.WriteLine("Last Write Time: " + fileInfo.LastWriteTime);
        }
        else
        {
            Console.WriteLine("File does not exist.");
        }
    }
}

In this example, we first create a `FileInfo` object using the file path. We then check if the file exists using the `Exists` property. If it exists, we print out various details about the file, such as the name, full path, parent directory, size, and last write time. If the file doesn't exist, we display a corresponding message.

 

By utilizing the `FileInfo` class, you can easily access file information and perform operations like reading, writing, or deleting files in C#.