---
# System prepended metadata

title: Untitled

---

### System.IO.Stream

A Stream classe e suas classes derivadas fornecem uma exibição genérica desses diferentes tipos de entrada e saída e isolam o programador dos detalhes específicos do sistema operacional e dos dispositivos subjacentes.
Fluxos envolvem estas três operações fundamentais:
- **Você pode ler de fluxos**. A leitura é a transferência de dados de um fluxo para uma estrutura de dados, como uma matriz de bytes.
- **Você pode gravar em fluxos**. A gravação é a transferência de dados de uma estrutura de dados para um fluxo.
- **Os fluxos podem dar suporte à busca**. A busca refere-se à consulta e à modificação da posição atual em um fluxo. A funcionalidade de busca depende do tipo de armazenamento de backup que um fluxo tem. Por exemplo, os fluxos de rede não têm um conceito unificado de uma posição atual e, portanto, normalmente não dão suporte à busca.

### System.IO.StreamReader

- StreamReader tem o padrão de codificação **UTF-8**, a menos que especificado de outra forma, em vez de padronizar para a página de código ANSI para o sistema atual.
- Por padrão, um StreamReader não é **thread-safe**. 

```csharp=
using (StreamWriter sw = new StreamWriter("text2.txt"))
{
    sw.NewLine = ";";

    sw.WriteLine("Hel{0}", "lo"); // Hello;
    sw.WriteLine("Hello World 2"); // Hello;Hello World 2;

    sw.Write(true); // Hello;Hello World 2;True
    sw.Write("Hello World 2"); // Hello;Hello World 2;TrueHello World 2
    sw.WriteLine("Hello World 2"); // Hello;Hello World 2;TrueHello World 2Hello World 2;

    var text = new char[5] { 'P', 'E', 'D', 'R', 'O' };

    sw.Write(text, 2, 3); // Hello;Hello World 2;TrueHello World 2Hello World 2;DRO
}
```

### System.IO.StreamWriter


- Não é Thread-Safe.
- UTF8.
- Async e sync.

```
Hello;
World;
```
> text.txt

<br/>

```csharp=
using (StreamReader sr = new StreamReader("text.txt"))
{
    var r = (Char)sr.Read();
    Console.WriteLine(r); // H

    var line = sr.ReadLine();
    Console.WriteLine(line); // ello;

    char[] buffer = new char[5];
    var iavel = sr.ReadBlock(buffer, 0, 2);

    Console.WriteLine(buffer); // Wo
    Console.WriteLine(iavel); // 2
}
```

### System.IO.FileStream

A classe é usada para executar o funcionamento básico da leitura e escrita de arquivos do sistema operacional. A classe FileStream ajuda na leitura, escrita e fechamento de arquivos.

```csharp=
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
 
namespace FileStream_CreateFile
{
    class Program
    {
        static void Main(string[] args)
        {                           
            FileStream fs = new FileStream("D:\\csharpfile.txt", FileMode.Create);                
            fs.Close();
            Console.Write("File has been created and the Path is D:\\csharpfile.txt");
            Console.ReadKey();
        }
    }
}
```

### System.IO.StringReader

Ele permite você ler uma string sincronizadamente ou assincronicamente. Você pode ler um caracter com Read() ou ler uma linha com ReadLine().

```csharp=
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
 
namespace StringReader_Class
{
    class Program
    {
        static void Main(string[] args)
        {            
            string text = @"AuAuAuAuAU";
 
            using (StringReader reader = new StringReader(text))
            {
                int count = 0;
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    count++;
                    Console.WriteLine("Line {0}: {1}", count, line);
                }
            }
            Console.ReadKey();
        }
    }
}
```



### System.IO.StringWriter

StringWriter classe é derivado da classe e é usado principalmente para manipular string em vez de arquivos. Permite que você escreva uma sequencia de string sincronizadamente ou assincronicamente. 

```csharp=
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
 
namespace StringWriter_Class
{
    class Program
    {
        static void Main(string[] args)
        {
            string text = "Hello. This is Line 1 \n Hello. This is Line 2 \nHello This is Line 3";

            StringBuilder sb = new StringBuilder();
            StringWriter writer = new StringWriter(sb);
            
            //Guarda a informação no StringBuilder
            writer.WriteLine(text);
            writer.Close();
            
            StringReader reader = new StringReader(sb.ToString());
            
            //Confere se chegou no fim do arquivo
            while (reader.Peek() > -1)
            {
                Console.WriteLine(reader.ReadLine());
            }
        }        
    }
}

```










### System.IO.MemoryStream

A classe `MemoryStream` cria fluxos que têm a memória como armazenamento de apoio, em vez de disco ou conexão de rede. 

`MemoryStream` encapsula dados armazenados como uma matriz de bytes não assinada. 

Os dados encapsulados podem ser acessados diretamente na memória. Os fluxos de memória podem reduzir a necessidade de buffers e arquivos temporários em um aplicativo.

* A posição atual de um fluxo é a posição em que ocorre a próxima operação de leitura ou gravação. 
* A posição atual pode ser recuperada ou definida por meio do método System.IO.MemoryStream.Seek (System.Int64, System.IO.SeekOrigin). 
* Quando uma nova instância de MemoryStream é criada, a posição atual é definida como zero.

Se um objeto MemoryStream for serializado em um arquivo de recurso, ele será, na verdade, serializado como um UnmanagedMemoryStream. Esse comportamento fornece melhor desempenho, bem como a capacidade de obter um ponteiro para os dados diretamente, sem precisar passar pelos métodos do Stream .

```csharp=

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
         string memString = "Memory test string !!";
		 
		// convert string to stream
		byte[] buffer = Encoding.ASCII.GetBytes(memString);
		
		using(var ms = new MemoryStream(buffer))
		{
			//write to file
			FileStream file = new FileStream("d:\\file.txt", FileMode.Create, FileAccess.Write);
			ms.WriteTo(file);
			file.Close();
			ms.Close();
		}
    }
}
```

### System.IO.BufferedStream

Um buffer é um bloco de bytes na memória usado para armazenar dados em cache, reduzindo assim o número de chamadas para o sistema operacional. 

Os buffers melhoram o desempenho de leitura e gravação. Um buffer pode ser usado para leitura ou gravação, mas nunca ambos simultaneamente.

```csharp=
using System;
using System.Diagnostics;
using System.IO;

class Program
{
    static void Main()
    {
        // Use BufferedStream to buffer writes to a MemoryStream.
        using (MemoryStream memory = new MemoryStream())
        using (BufferedStream stream = new BufferedStream(memory))
        {
            // Write a byte 5 million times.
            for (int i = 0; i < 5000000; i++)
            {
                stream.WriteByte(5);
            }
        }
        
    }
}
```

### System.IO.UnmanagedMemoryStream

Essa classe dá suporte ao acesso à memória não gerenciada usando o modelo existente baseado em fluxo e não requer que o conteúdo na memória não gerenciada seja copiado para o heap.

Um bloco de memória não gerenciada é alocado e desalocado usando a Marshal classe.

```csharp=
// Note: you must compile this sample using the unsafe flag.
// From the command line, type the following: csc sample.cs /unsafe

using System;
using System.IO;
using System.Text;
using System.Runtime.InteropServices;

unsafe class TestWriter
{
    static void Main()
    {
        // Create some data to read and write.
        byte[] message = UnicodeEncoding.Unicode.GetBytes("Here is some data.");

        // Allocate a block of unmanaged memory and return an IntPtr object.	
        IntPtr memIntPtr = Marshal.AllocHGlobal(message.Length);

        // Get a byte pointer from the IntPtr object.
        byte* memBytePtr = (byte*)memIntPtr.ToPointer();

        // Create an UnmanagedMemoryStream object using a pointer to unmanaged memory.
        var writeStream = new UnmanagedMemoryStream(memBytePtr, message.Length, message.Length, FileAccess.Write);

        // Write the data.
        writeStream.Write(message, 0, message.Length);

        // Close the stream.
        writeStream.Close();

        // Create another UnmanagedMemoryStream object using a pointer to unmanaged memory.
        var readStream = new UnmanagedMemoryStream(memBytePtr, message.Length, message.Length, FileAccess.Read);

        // Create a byte array to hold data from unmanaged memory.
        byte[] outMessage = new byte[message.Length];

        // Read from unmanaged memory to the byte array.
        readStream.Read(outMessage, 0, message.Length);

        // Close the stream.
        readStream.Close();

        // Display the data to the console.
        Console.WriteLine(UnicodeEncoding.Unicode.GetString(outMessage));

        // Free the block of unmanaged memory.
        Marshal.FreeHGlobal(memIntPtr);

        Console.ReadLine();
    }
}
```