Definition
-
Text Stream: Used to read and write character data (text) from sources like files, memory, and network using encoding-aware classes such as StreamReader and StreamWriter.
-
Binary Stream: Used for reading and writing raw binary data (bytes) using classes like BinaryReader and BinaryWriter.
Features
-
Both text and binary streams inherit from the abstract base class System.IO.Stream.
-
Provide sequential data access (read/write)
-
Support synchronous and asynchronous operations
-
Text streams handle encoding automatically, binary streams deal with raw bytes.
2. System.IO and Base Classes of Stream
System.IO Namespace
-
Contains types to perform input/output operations on streams and files.
-
Includes classes like Stream, File, FileInfo, Directory, DirectoryInfo, Path, FileStream, StreamReader, StreamWriter, BinaryReader, and BinaryWriter.
Stream Class (Base Class)
Definition
-
An abstract class that provides a generic view of a sequence of bytes.
Key Features
-
Supports reading, writing, and seeking operations.
-
Has properties CanRead, CanWrite, CanSeek, Position, Length.
-
Implements IDisposable for resource management.
-
Supports synchronous and asynchronous methods (Read, ReadAsync, Write, WriteAsync).
-
Derived classes must implement Read and Write methods.
3. Console I/O Streams
Console Class (System Namespace)
-
Provides standard input, output, and error streams for console applications.
-
Key properties: Console.In (TextReader), Console.Out (TextWriter), Console.Error (TextWriter).
-
Supports reading from keyboard and writing to screen.
-
Allows redirection of input/output to other streams.
-
Supports methods like ReadLine(), WriteLine(), ReadKey() for interaction.
4. Working with File System
4.1 File Class
-
Provides static methods for creating, copying, deleting, moving, and opening files.
-
Works with file paths as strings.
-
Simple and easy-to-use for common file operations.
4.2 FileInfo Class
-
Represents a file in the file system with properties and instance methods.
-
Allows detailed information (size, attributes, dates) retrieval and instance operations.
-
Better suited for repeated operations on the same file as it holds state.
4.3 Directory Class
-
Provides static methods for creating, moving, and enumerating directories and subdirectories.
-
Operates with directory paths as strings.
-
Includes methods to check existence and get directory contents.
4.4 DirectoryInfo Class
-
Represents a directory and exposes instance methods and properties for detailed operations.
-
Supports enumeration of files and subdirectories with rich metadata.
-
Optimized for repeated access to a specific directory.
Code Examples
# Install .NET CLI tool for file operations (example)
dotnet add package System.IO
using System;
using System.IO;
class StreamExamples
{
private static readonly string filePath = "sample.txt";
public static void TextStreamExample()
{
// Writing text to a file using StreamWriter (text stream)
using (StreamWriter writer = new StreamWriter(filePath))
{
writer.WriteLine("Hello, world!");
writer.WriteLine("This is a text stream example.");
}
// Reading text from a file using StreamReader (text stream)
using (StreamReader reader = new StreamReader(filePath))
{
string content = reader.ReadToEnd();
Console.WriteLine("File Contents:");
Console.WriteLine(content);
}
}
public static void BinaryStreamExample()
{
byte[] data = new byte[] { 0, 1, 2, 3, 4, 5 };
// Write binary data to a file
using (FileStream fs = new FileStream("binarydata.bin", FileMode.Create))
{
fs.Write(data, 0, data.Length);
}
// Read binary data from a file
using (FileStream fs = new FileStream("binarydata.bin", FileMode.Open))
{
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
Console.WriteLine("Binary Data:");
foreach (var b in buffer)
{
Console.Write(b + " ");
}
Console.WriteLine();
}
}
public static void ConsoleIOExample()
{
Console.WriteLine("Enter your name:");
string name = Console.ReadLine();
Console.WriteLine($"Hello, {name}!");
}
public static void FileAndDirectoryExample()
{
// Using File class to create a file
string path = "testfile.txt";
File.WriteAllText(path, "Sample text");
// Using FileInfo class
FileInfo fileInfo = new FileInfo(path);
Console.WriteLine($"File size: {fileInfo.Length} bytes");
// Using Directory class
string dir = "TestDir";
Directory.CreateDirectory(dir);
// Using DirectoryInfo class
DirectoryInfo dirInfo = new DirectoryInfo(dir);
Console.WriteLine($"Directory exists: {dirInfo.Exists}");
}
static void Main()
{
TextStreamExample();
BinaryStreamExample();
ConsoleIOExample();
FileAndDirectoryExample();
}
}
This format follows your previous pattern with numbered and lettered main sections, clear headers, subsections, bulleted lists for features and differences, and code blocks for examples.
Footnotes
-
https://learn.microsoft.com/en-us/dotnet/api/system.io.stream?view=net-9.0 ↩
-
https://www.c-sharpcorner.com/UploadFile/f0b2ed/inputoutput-classes-in-C-Sharp/ ↩
-
https://reintech.io/blog/working-with-the-net-csharp-streams-and-io-classes ↩
-
https://www.c-sharpcorner.com/UploadFile/prvn_131971/system-io-and-streams-in-C-Sharp/ ↩
-
https://stackoverflow.com/questions/1404303/c-sharp-using-streams ↩