To handle file streams and I/O operations in C#, you need to master core classes and modes such as FileStream, StreamReader, asynchronous I/O and path processing. 1. Use FileStream to perform underlying file operations, support synchronization/asynchronous and access mode control, and use to ensure resource release and pay attention to FileMode and FileShare settings; 2. StreamReader and StreamWriter provide text read and write encapsulation, which is simpler and easier to use, can specify encoding methods, and can simplify one-time operations by File.ReadAllText() and other simplify one-time operations; 3. Asynchronous I/O improves responsiveness through async/await, suitable for large files or network operations, and is recommended in UI or web applications to avoid mixed synchronous asynchronous to prevent deadlocks; 4. When processing paths, use the Path.Combine and Exists() methods to ensure path correctness and exception prevention, and build a directory structure with Directory.CreateDirectory.

Handling file streaming and I/O operations in C# is a very basic but error-prone part of development. Whether reading and writing text files, manipulating binary data, or performing asynchronous operations, you need to have a certain understanding of FileStream, StreamReader and other related classes.

1. Use FileStream to perform underlying file operations

FileStream is one of the most commonly used classes in C# for directly interacting with the file system. It supports synchronous and asynchronous operations, and can control the access mode of files (such as read-only, write, append) and sharing methods.

Basic usage:

 using (var fs = new FileStream("example.txt", FileMode.OpenOrCreate, FileAccess.Write))
{
    byte[] info = new UTF8Encoding(true).GetBytes("Hello, file!");
    fs.Write(info, 0, info.Length);
}

Notes:

• Always use the using statement to ensure that the stream is released correctly.
• Pay attention to the different options of FileMode , such as OpenOrCreate , Append , etc.
• If multiple threads or processes may access the file at the same time, consider setting the appropriate FileShare parameters.

2. Quickly process text with StreamReader and StreamWriter

If you only need to read and write text content, you can use higher-level encapsulation classes: StreamReader and StreamWriter , which are built on FileStream , but are more concise to use.

Example of reading the entire file:

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

Examples of writing text:

 using (var writer = new StreamWriter("output.txt"))
{
    writer.WriteLine("This is a line of text.");
}

Tips:

• The encoding method can be specified through the constructor, such as new StreamWriter("file.txt", Encoding.UTF8) .
• If you just want to read the entire file at once, you can use File.ReadAllText() or File.ReadAllLines() .

3. Asynchronous I/O improves responsiveness

For large files or network file operations, it is recommended to use asynchronous methods to avoid blocking the main thread. C# provides async/await support, making the code efficient and easy to maintain.

Asynchronous reading example:

 private async Task ReadFileAsync(string path)
{
    using (var reader = new StreamReader(path))
    {
        string content = await reader.ReadToEndAsync();
        Console.WriteLine(content);
    }
}

Asynchronous writing example:

 private async Task WriteFileAsync(string path, string content)
{
    using (var writer = new StreamWriter(path))
    {
        await writer.WriteAsync(content);
    }
}

suggestion:

• Try to use asynchronous versions in UI applications or Web APIs to improve user experience and throughput.
• Do not mix synchronous and asynchronous operations to avoid deadlock problems.
• Remember to add await when calling the asynchronous method.

4. Process path and file existence check

In actual projects, it is often necessary to determine whether the file exists or build the correct file path. Although this part is simple, it is also very important.

Common practices include:

• Check if the file exists:

   if (File.Exists("data.txt"))
  {
      // Perform an action}

• Get the full path:

   string fullPath = Path.GetFullPath("relative/path/file.txt");

• Merge path fragments:

   string filePath = Path.Combine("folder", "subfolder", "file.txt");

  Note:

  • The path separator should not be hard-coded, use Path.DirectorySeparatorChar or Path.Combine .
  • It is best to check whether it exists before file operation to avoid throwing exceptions.
  • You can create a directory structure in conjunction with Directory.CreateDirectory() .

  ---

  Basically these common operations. By mastering these core classes and patterns, you can flexibly handle various file I/O requirements in C#.

  The above is the detailed content of Working with File Streams and I/O Operations in C#. For more information, please follow other related articles on the PHP Chinese website!