What are C# Streams and How to use them

In C#, streams are a fundamental concept for working with input and output operations, allowing you to work with data in a sequential and efficient manner. Streams provide an abstraction over different sources and destinations of data, such as files, network sockets, memory, and more. Streams provide a consistent interface for reading and writing data, regardless of the underlying source or destination.

In C#, the `System.IO` namespace provides various stream classes and related types for performing I/O operations. Here are some of the key stream classes in C#:

1. `Stream`: This is the abstract base class for all stream types. It provides basic methods and properties for reading and writing bytes.

2. `FileStream`: Used for reading from and writing to files on disk.

3. `MemoryStream`: Provides an in-memory stream that allows you to read and write data to and from a byte array in memory.

4. `NetworkStream`: Used for reading and writing data over network sockets.

5. `CryptoStream`: A specialized stream used for cryptographic operations, such as encryption and decryption.

6. `BufferedStream`: Wraps another stream and adds buffering for improved performance.

7. `StreamReader` and `StreamWriter`: These classes are used for reading and writing text data using streams, and they provide character encoding support.

8. `BinaryReader` and `BinaryWriter`: These classes are used for reading and writing binary data using streams.

Streams in C# typically follow a pattern where you create an instance of a specific stream type, perform read or write operations on it, and then close the stream when you're done to release any associated resources.

Here's a simplified example of reading from a file using a `FileStream`:

```csharp
using System;
using System.IO;

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

        using (FileStream fs = new FileStream(filePath, FileMode.Open))
        using (StreamReader reader = new StreamReader(fs))
        {
            string line;
            while ((line = reader.ReadLine()) != null)
            {
                Console.WriteLine(line);
            }
        }
    }
}
```

In this example, we open a file stream (`FileStream`) and read its content line by line using a `StreamReader`. Streams are a powerful and flexible way to handle various I/O scenarios in C#.