Stream Classe

Definição

public ref class Stream abstract : IDisposable

public ref class Stream abstract : MarshalByRefObject, IDisposable

public ref class Stream abstract : MarshalByRefObject, IAsyncDisposable, IDisposable

public abstract class Stream : IDisposable

[System.Serializable]
public abstract class Stream : MarshalByRefObject, IDisposable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Stream : MarshalByRefObject, IDisposable

public abstract class Stream : MarshalByRefObject, IDisposable

public abstract class Stream : MarshalByRefObject, IAsyncDisposable, IDisposable

type Stream = class
    interface IDisposable

[<System.Serializable>]
type Stream = class
    inherit MarshalByRefObject
    interface IDisposable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Stream = class
    inherit MarshalByRefObject
    interface IDisposable

type Stream = class
    inherit MarshalByRefObject
    interface IDisposable

type Stream = class
    inherit MarshalByRefObject
    interface IAsyncDisposable
    interface IDisposable

Public MustInherit Class Stream
Implements IDisposable

Public MustInherit Class Stream
Inherits MarshalByRefObject
Implements IDisposable

Public MustInherit Class Stream
Inherits MarshalByRefObject
Implements IAsyncDisposable, IDisposable

Herança

Object

Stream

Herança

Object

MarshalByRefObject

Stream

Derivado

Microsoft.JScript.COMCharStream

System.Data.OracleClient.OracleBFile

System.Data.OracleClient.OracleLob

System.Data.SqlTypes.SqlFileStream

System.IO.BufferedStream

Mais…

Atributos

SerializableAttribute ComVisibleAttribute

Implementações

IDisposable IAsyncDisposable

Exemplos

O exemplo seguinte demonstra como usar dois FileStream objetos para copiar assíncronamente os ficheiros de um diretório para outro. A FileStream classe deriva da Stream classe. Observe que o Click manipulador de eventos para o Button controle está marcado com o async modificador porque ele chama um método assíncrono.

using System;
using System.Threading.Tasks;
using System.Windows;
using System.IO;

namespace WpfApplication
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private async void Button_Click(object sender, RoutedEventArgs e)
        {
            string StartDirectory = @"c:\Users\exampleuser\start";
            string EndDirectory = @"c:\Users\exampleuser\end";

            foreach (string filename in Directory.EnumerateFiles(StartDirectory))
            {
                using (FileStream SourceStream = File.Open(filename, FileMode.Open))
                {
                    using (FileStream DestinationStream = File.Create(EndDirectory + filename.Substring(filename.LastIndexOf('\\'))))
                    {
                        await SourceStream.CopyToAsync(DestinationStream);
                    }
                }
            }
        }
    }
}

Imports System.IO

Class MainWindow

    Private Async Sub Button_Click(sender As Object, e As RoutedEventArgs)
        Dim StartDirectory As String = "c:\Users\exampleuser\start"
        Dim EndDirectory As String = "c:\Users\exampleuser\end"

        For Each filename As String In Directory.EnumerateFiles(StartDirectory)
            Using SourceStream As FileStream = File.Open(filename, FileMode.Open)
                Using DestinationStream As FileStream = File.Create(EndDirectory + filename.Substring(filename.LastIndexOf("\"c)))
                    Await SourceStream.CopyToAsync(DestinationStream)
                End Using

            End Using
        Next
    End Sub

End Class

Observações

Stream é a classe base abstrata de todos os fluxos. Um fluxo é uma abstração de uma sequência de bytes, como um ficheiro, um dispositivo de entrada/saída, um canal de comunicação entre processos ou um socket TCP/IP. A Stream classe e as suas classes derivadas fornecem uma visão genérica destes diferentes tipos de entrada e saída, isolando o programador dos detalhes específicos do sistema operativo e dos dispositivos subjacentes.

Os fluxos envolvem três operações fundamentais:

• Podes ler nos streams. A leitura é a transferência de dados de um fluxo para uma estrutura de dados, como um array de bytes.

• Podes escrever para streams. Escrita é a transferência de dados de uma estrutura de dados para um fluxo.

• Os streams podem suportar a procura. Seeking refere-se a consultar e modificar a posição atual dentro de um fluxo. A capacidade de seek depende do tipo de backing store que um stream tem. Por exemplo, os fluxos de rede não têm um conceito unificado de posição atual e, por isso, normalmente não suportam a procura.

Alguns dos fluxos mais usados que herdam de Stream , FileStreame MemoryStream.

Dependendo da fonte de dados subjacente ou repositório, os fluxos podem suportar apenas algumas destas capacidades. Pode consultar um fluxo para as suas capacidades usando , CanReadCanWrite, e CanSeek propriedades da Stream classe.

Os Read métodos and Write leem e escrevem dados em vários formatos. Para fluxos que suportam a procura, use os Seek métodos e Position propriedades e LengthSetLength e para consultar e modificar a posição atual e o comprimento de um fluxo.

Este tipo implementa a interface IDisposable. Quando terminar de usar o tipo, você deve eliminá-lo direta ou indiretamente. Para descartar o tipo diretamente, chame seu método Dispose em um bloco try/catch. Para descartá-lo indiretamente, use uma construção de linguagem como using (em C#) ou Using (em Visual Basic). Para obter mais informações, consulte a seção "Usando um objeto que implementa IDisposable" no tópico da IDisposable interface.

Eliminar um Stream objeto elimina qualquer dado armazenado em buffer e, essencialmente, chama o Flush método por si. Dispose também liberta recursos do sistema operativo, como handles de ficheiros, ligações de rede ou memória usada para qualquer buffering interno. A BufferedStream classe oferece a capacidade de envolver um fluxo em buffer em torno de outro fluxo para melhorar o desempenho de leitura e escrita.

A partir do .NET Framework 4.5, a classe Stream inclui métodos assíncronos para simplificar operações assíncronas. Um método assíncrono contém Async no seu nome, como ReadAsync, WriteAsync, CopyToAsync, e FlushAsync. Estes métodos permitem-lhe realizar operações de I/O que consomem muitos recursos sem bloquear o thread principal. Essa consideração de desempenho é particularmente importante em um aplicativo da Windows Store 8.x ou aplicativo da área de trabalho, onde uma operação de fluxo demorada pode bloquear o thread da interface do usuário e fazer com que seu aplicativo pareça como se não estivesse funcionando. Os métodos assíncronos são usados em conjunto com as palavras-chave async e await em Visual Basic e C#.

Quando usado numa aplicação Windows 8.x Store, Stream inclui dois métodos de extensão: AsInputStream e AsOutputStream. Estes métodos convertem um objeto Stream num fluxo no Windows Runtime. Também pode converter um fluxo no Windows Runtime para um objeto Stream usando os métodos AsStreamForRead e AsStreamForWrite. Para mais informações, consulte Como: Converter entre fluxos .NET framework e fluxos Windows Runtime

Algumas implementações de fluxos realizam buffering local dos dados subjacentes para melhorar o desempenho. Para esses fluxos, pode usar o Flush método ou FlushAsync para limpar quaisquer buffers internos e garantir que todos os dados foram escritos na fonte de dados ou repositório subjacente.

Se precisar de um fluxo sem armazenamento de suporte (também conhecido como balde de bits), use o Null campo para recuperar uma instância de um fluxo concebido para este propósito.

Notas para Implementadores

Quando implementa uma classe derivada de Stream, deve fornecer implementações para os Read(Byte[], Int32, Int32) métodos e.Write(Byte[], Int32, Int32) Os métodos ReadAsync(Byte[], Int32, Int32)assíncronos , WriteAsync(Byte[], Int32, Int32), e CopyToAsync(Stream) usam os métodos Read(Byte[], Int32, Int32) síncronos e Write(Byte[], Int32, Int32) nas suas implementações. Portanto, as suas implementações de Read(Byte[], Int32, Int32) e Write(Byte[], Int32, Int32) funcionarão corretamente com os métodos assíncronos. As implementações padrão de ReadByte() e WriteByte(Byte) criam um novo array de bytes de elemento único, e depois chamam as suas implementações de Read(Byte[], Int32, Int32) e Write(Byte[], Int32, Int32). Quando deriva de Stream, recomendamos que sobrescrita estes métodos para aceder ao seu buffer interno, se tiver um, para um desempenho substancialmente melhor. Deve também fornecer implementações de CanRead, CanSeek, CanWrite, Flush(), LengthPosition, , Seek(Int64, SeekOrigin), e SetLength(Int64).

Não sobrepiques o Close() método, em vez disso, coloca toda a Stream lógica de limpeza no Dispose(Boolean) método. Para mais informações, consulte Implementar um Método de Eliminação.

Ver também

• FileStream
• MemoryStream
• BufferedStream
• E/S de arquivo e fluxo
• Como: Converter entre fluxos .NET framework e fluxos Windows Runtime