> For the complete documentation index, see [llms.txt](https://dotnetweb30-ke.gitbook.io/ke/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://dotnetweb30-ke.gitbook.io/ke/construction-core/programming-language/system.io-namespace.md).

# System.IO namespace

### Abstract Stream Class

{% hint style="success" %}
In the world of I/O manipulation, a **stream** represents a chunk of data flowing between a source and a destination.
{% endhint %}

Streams provide a common way to interact with a *sequence of bytes*, regardless of what kind of device (e.g., file, network connection, or printer) stores or displays the bytes in question.

The abstract `System.IO.Stream` class defines several members that provide support for synchronous and asynchronous interactions with the storage medium (e.g., an underlying file or memory location).

| Member                                      | Meaning in Life                                                                                                                                            |
| ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <p>CanRead</p><p>CanWrite</p><p>CanSeek</p> | Determines whether the current stream supports reading, seeking, and/or writing.                                                                           |
| Close()                                     | Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Kinda `Dispose()` for streams. |
| Flush()                                     | Updates the underlying data source or repository with the current state of the buffer and then clears the buffer.                                          |
| Length                                      | Returns the length of the stream in bytes.                                                                                                                 |
| Position                                    | Determines the position in the current stream.                                                                                                             |
| <p>Read()</p><p>ReadByte()</p>              | Reads a sequence of bytes (or a single byte) from the current stream and advances the current position in the stream by the number of bytes read.          |
| Seek()                                      | Sets the position in the current stream.                                                                                                                   |
| SetLength()                                 | Sets the length of the current stream.                                                                                                                     |
| <p>Write()</p><p>WriteByte(</p>             | Writes a sequence of bytes (or a single byte) to the current stream and advances the current position in this stream by the number of bytes written.       |

### StreamWriters and StreamReaders

The `StreamWriter` and `StreamReader` classes are useful whenever you need to read or write character-based data (e.g., strings). Both of these types work by default with Unicode characters; however, you can change this by supplying a properly configured `System.Text.Encoding` object reference.

#### StreamReader

`StreamReader` derives from an abstract type named `TextReader`, as does the related `StringReader` type. The `TextReader` base class provides a limited set of functionality to each of these descendants; specifically it provides the ability to read and peek into a character stream.

#### StreamWriter

The `StreamWriter` type (as well as `StringWriter`) derives from an abstract base class named `TextWriter`. This class defines members that allow derived types to write textual data to a given character stream.

```csharp
static void Main(string[] args)
{
    // Get a StreamWriter and write string data.
    using(StreamWriter writer = File.CreateText("reminders.txt"))
    {
        writer.WriteLine("Don't forget these numbers:");
        for(int i = 0; i < 10; i++)
            writer.Write(i + " ");
        
        // Insert a new line.
        writer.Write(writer.NewLine);
    }
}
```

### StringWriters and StringReaders

You can use the `StringWriter` and `StringReader` types to treat textual information as a stream of in-memory characters. This can prove helpful when you would like to append character-based information to an underlying buffer.

```csharp
static void Main(string[] args)
{
    // Create a StringWriter and emit character data to memory.
    using(StringWriter strWriter = new StringWriter())
    {
        strWriter.WriteLine("Don't forget Mother's Day this year...");
        
        // Get a copy of the contents (stored in a string) and dump to console.
        Console.WriteLine("Contents of StringWriter:\n{0}", strWriter);
    }
    Console.ReadLine();
}
```

`StringWriter` and `StreamWriter` both derive from the same base class (`TextWriter`), so the writing logic is more or less identical. However, given the nature of `StringWriter`, you can use **`GetStringBuilder()`** method to extract a `System.Text.StringBuilder` object.

### Watching Files Programmatically

**`FileSystemWatcher`** class can be quite helpful when you want to monitor (or “watch”) files on your system programmatically. Specifically, you can instruct the `FileSystemWatcher` type to monitor files for any of the actions specified by the `System.IO.NotifyFilters` enumeration:

```csharp
public enum NotifyFilters
{
    Attributes, CreationTime,
    DirectoryName, FileName,
    LastAccess, LastWrite,
    Security, Size
}
```

You can also specify filename regex filter.

```csharp
static void Main(string[] args)
{
   // Establish the path to the directory to watch.
   FileSystemWatcher watcher = new FileSystemWatcher();
   try
   {
      watcher.Path = @"C:\MyFolder";
   }
   catch(ArgumentException ex)
   {
      Console.WriteLine(ex.Message);
      return;
   }
   
   // Set up the things to be on the lookout for.
   watcher.NotifyFilter = NotifyFilters.LastAccess
      | NotifyFilters.LastWrite
      | NotifyFilters.FileName
      | NotifyFilters.DirectoryName;
   
   // Only watch text files.
   watcher.Filter = "*.txt";
   
   // Add event handlers.
   watcher.Changed += new FileSystemEventHandler(OnChanged);
   watcher.Created += new FileSystemEventHandler(OnChanged);
   watcher.Deleted += new FileSystemEventHandler(OnChanged);
   watcher.Renamed += new RenamedEventHandler(OnRenamed);
   
   // Begin watching the directory.
   watcher.EnableRaisingEvents = true;
   
   // Wait for the user to quit the program.
   Console.WriteLine(@"Press 'q' to quit app.");
   while(Console.Read()!='q');
} 
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://dotnetweb30-ke.gitbook.io/ke/construction-core/programming-language/system.io-namespace.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.