Stream Classe

Definizione

Fornisce una visualizzazione generica di una sequenza di byte. Questa è una classe abstract.

public ref class Stream abstract : IDisposable
public ref class Stream abstract : MarshalByRefObject, IAsyncDisposable, IDisposable
public ref class Stream abstract : MarshalByRefObject, IDisposable
public abstract class Stream : IDisposable
public abstract class Stream : MarshalByRefObject, IAsyncDisposable, IDisposable
public abstract class Stream : MarshalByRefObject, IDisposable
[System.Serializable]
public abstract class Stream : MarshalByRefObject, IDisposable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Stream : MarshalByRefObject, IDisposable
type Stream = class
    interface IDisposable
type Stream = class
    inherit MarshalByRefObject
    interface IAsyncDisposable
    interface IDisposable
type Stream = class
    inherit MarshalByRefObject
    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
Public MustInherit Class Stream
Implements IDisposable
Public MustInherit Class Stream
Inherits MarshalByRefObject
Implements IAsyncDisposable, IDisposable
Public MustInherit Class Stream
Inherits MarshalByRefObject
Implements IDisposable
Ereditarietà
Stream
Ereditarietà
Derivato
Attributi
Implementazioni

Esempio

Nell'esempio seguente viene illustrato come utilizzare due oggetti per copiare in modo asincrono FileStream i file da una directory a un'altra directory. La classe FileStream deriva dalla classe Stream . Si noti che il gestore eventi Click per il controllo Button è contrassegnato con il modificatore async perché chiama un metodo asincrono.

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

Commenti

Stream è la classe base astratta di tutti i flussi. Un flusso è un'astrazione di una sequenza di byte, ad esempio un file, un dispositivo di input/output, una pipe di comunicazione tra processi o un socket TCP/IP. La classe e le relative classi derivate forniscono una visualizzazione generica di questi diversi tipi di input e output e isolano il programmatore dai dettagli specifici del sistema operativo e Stream dei dispositivi sottostanti.

I flussi implicano tre operazioni fondamentali:

  • È possibile leggere dai flussi. La lettura è il trasferimento di dati da un flusso in una struttura di dati, ad esempio una matrice di byte.

  • È possibile scrivere nei flussi. La scrittura è il trasferimento di dati da una struttura di dati in un flusso.

  • Flussi può supportare la ricerca. La ricerca si riferisce all'esecuzione di query e alla modifica della posizione corrente all'interno di un flusso. La funzionalità di ricerca dipende dal tipo di archivio di backup di un flusso. Ad esempio, i flussi di rete non hanno un concetto unificato di posizione corrente e pertanto in genere non supportano la ricerca.

Alcuni dei flussi più comunemente usati che ereditano da Stream sono FileStream , e MemoryStream .

A seconda dell'origine dati o del repository sottostante, i flussi potrebbero supportare solo alcune di queste funzionalità. È possibile eseguire una query su un flusso per le relative funzionalità usando le proprietà CanRead , e della classe CanWrite CanSeek Stream .

I Read metodi Write e leggono e scrivono dati in diversi formati. Per i flussi che supportano la ricerca, usare i metodi e e le proprietà e per eseguire query e modificare la posizione e la Seek lunghezza correnti di un SetLength Position Length flusso.

Il tipo implementa l'interfaccia IDisposable. Dopo aver utilizzato il tipo, è necessario eliminarlo direttamente o indirettamente. Per eliminare direttamente il tipo, chiamare il metodo Dispose in un blocco try/catch. Per eliminarlo indirettamente, utilizzare un costrutto di linguaggio come ad esempio using in C# o Using in Visual Basic. Per altre informazioni, vedere la sezione "Uso di un oggetto che implementa IDisposable" nell'argomento relativo all'interfaccia IDisposable.

L'eliminazione di Stream un oggetto scarica tutti i dati memorizzati nel buffer ed essenzialmente chiama il metodo per Flush l'utente. Dispose rilascia anche risorse del sistema operativo, ad esempio handle di file, connessioni di rete o memoria utilizzata per qualsiasi buffer interno. La classe consente di eseguire il wrapping di un flusso memorizzato nel buffer intorno a un altro flusso per migliorare BufferedStream le prestazioni di lettura e scrittura.

A partire da .NET Framework 4.5, la classe Stream include metodi asincroni per semplificare le operazioni asincrone. Un metodo asincrono Async contiene nel nome, ad esempio ReadAsync , , e WriteAsync CopyToAsync FlushAsync . Questi metodi consentono di eseguire operazioni di I/O a elevato utilizzo di risorse senza bloccare il thread principale. Questa considerazione sulle prestazioni è particolarmente importante in un'app Windows 8.x Store o un'app desktop in cui un'operazione di flusso dispendiosa in termini di tempo può bloccare il thread dell'interfaccia utente e far apparire l'app come se non funziona. I metodi asincroni vengono usati in combinazione con le parole chiave async e in Visual Basic e await C#.

Se usato in un'app Windows 8.x Store, Stream include due metodi di estensione: e AsInputStream AsOutputStream . Questi metodi convertono Stream un oggetto in un flusso in Windows Runtime. È anche possibile convertire un flusso in Windows Runtime in un Stream oggetto usando i metodi e AsStreamForRead AsStreamForWrite . Per altre informazioni, vedere Procedura: Eseguire la conversione tra .NET Framework Flussi e Windows Runtime Flussi

Alcune implementazioni del flusso eseguono il buffering locale dei dati sottostanti per migliorare le prestazioni. Per tali flussi, è possibile usare il metodo o per cancellare tutti i buffer interni e assicurarsi che tutti i dati siano stati scritti nell'origine dati o nel Flush FlushAsync repository sottostante.

Se è necessario un flusso senza archivio di backup (noto anche come bucket di bit), usare il campo per recuperare un'istanza di un flusso progettato a Null questo scopo.

Note per gli implementatori

Quando si implementa una classe derivata di Stream , è necessario fornire implementazioni per i metodi e Read(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) . I metodi ReadAsync(Byte[], Int32, Int32) asincroni WriteAsync(Byte[], Int32, Int32) , e usano i CopyToAsync(Stream) metodi sincroni e nelle relative Read(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) implementazioni. Di conseguenza, le implementazioni di Read(Byte[], Int32, Int32) e funzionano correttamente con i metodi Write(Byte[], Int32, Int32) asincroni. Le implementazioni predefinite di e creano una nuova matrice di byte a elemento singolo e quindi chiamano ReadByte() WriteByte(Byte) le implementazioni di e Read(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) . Quando si deriva da , è consigliabile eseguire l'override di questi metodi per accedere al buffer interno, se necessario, per ottenere Stream prestazioni notevolmente migliori. È inoltre necessario fornire implementazioni di CanRead , , , , , , , e CanSeek CanWrite Flush() Length Position Seek(Int64, SeekOrigin) SetLength(Int64) .

Non eseguire l'override Close() del metodo , ma inserire tutta la logica di pulizia nel metodo Stream Dispose(Boolean) . Per altre informazioni, vedere Implementazione di un metodo Dispose.

Costruttori

Stream()

Inizializza una nuova istanza della classe Stream.

Campi

Null

Oggetto Stream privo di archivio di backup.

Proprietà

CanRead

Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la lettura.

CanSeek

Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la ricerca.

CanTimeout

Ottiene un valore che determina se il flusso corrente prevede il timeout.

CanWrite

Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la scrittura.

Length

Quando ne viene eseguito l'override in una classe derivata, ottiene la lunghezza in byte del flusso.

Position

Quando ne viene eseguito l'override in una classe derivata, ottiene o imposta la posizione all'interno del flusso corrente.

ReadTimeout

Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout.

WriteTimeout

Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout.

Metodi

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Inizia un'operazione di lettura asincrona. Si consiglia di usare ReadAsync(Byte[], Int32, Int32).

BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Inizia un'operazione di scrittura asincrona. Si consiglia di usare WriteAsync(Byte[], Int32, Int32).

Close()

Chiude il flusso corrente e libera le risorse, come socket e handle di file, ad esso associate. Anziché chiamare questo metodo, assicurarsi che il flusso sia eliminato correttamente.

CopyTo(Stream)

Legge i byte dal flusso corrente e li scrive in un altro flusso.

CopyTo(Stream, Int32)

Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata.

CopyToAsync(Stream)

Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso.

CopyToAsync(Stream, CancellationToken)

Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando un token di annullamento specificato.

CopyToAsync(Stream, Int32)

Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, utilizzando una dimensione di buffer specificata.

CopyToAsync(Stream, Int32, CancellationToken)

Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento.

CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.

(Ereditato da MarshalByRefObject)
CreateWaitHandle()
Obsoleta.
Obsoleta.

Alloca un oggetto WaitHandle.

Dispose()

Rilascia tutte le risorse usate da Stream.

Dispose(Boolean)

Rilascia le risorse non gestite usate da Stream e, facoltativamente, le risorse gestite.

DisposeAsync()

Consente di liberare in modo asincrono le risorse non gestite utilizzate da Stream.

EndRead(IAsyncResult)

Attende il completamento della lettura asincrona in sospeso. Si consiglia di usare ReadAsync(Byte[], Int32, Int32).

EndWrite(IAsyncResult)

Termina un'operazione di scrittura asincrona. Si consiglia di usare WriteAsync(Byte[], Int32, Int32).

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
Flush()

Quando ne viene eseguito l'override in una classe derivata, cancella tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante.

FlushAsync()

Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante.

FlushAsync(CancellationToken)

Cancella in modo asincrono i dati di tutti i buffer del flusso, determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento.

GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetLifetimeService()
Obsoleta.

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.

(Ereditato da MarshalByRefObject)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
InitializeLifetimeService()
Obsoleta.

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.

(Ereditato da MarshalByRefObject)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.

(Ereditato da MarshalByRefObject)
ObjectInvariant()
Obsoleta.

Fornisce supporto per un oggetto Contract.

Read(Byte[], Int32, Int32)

Quando ne viene eseguito l'override in una classe derivata, legge una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti.

Read(Span<Byte>)

Quando ne viene eseguito l'override in una classe derivata, legge una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti.

ReadAsync(Byte[], Int32, Int32)

Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti.

ReadAsync(Byte[], Int32, Int32, CancellationToken)

Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento.

ReadAsync(Memory<Byte>, CancellationToken)

Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento.

ReadByte()

Legge un byte dal flusso e sposta in avanti la posizione corrente all'interno del flusso di un byte o restituisce -1 se si trova alla fine del flusso.

Seek(Int64, SeekOrigin)

Quando ne viene eseguito l'override in una classe derivata, imposta la posizione all'interno del flusso corrente.

SetLength(Int64)

Quando ne viene eseguito l'override in una classe derivata, imposta la lunghezza del flusso corrente.

Synchronized(Stream)

Crea un wrapper thread-safe (sincronizzato) per l'oggetto Stream.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)
ValidateBufferArguments(Byte[], Int32, Int32)

Convalida gli argomenti forniti per la lettura e la scrittura di metodi in Stream .

ValidateCopyToArguments(Stream, Int32)

Convalida gli argomenti forniti ai CopyTo(Stream, Int32) metodi o CopyToAsync(Stream, Int32, CancellationToken) .

Write(Byte[], Int32, Int32)

Quando ne viene eseguito l'override in una classe derivata, scrive una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti.

Write(ReadOnlySpan<Byte>)

Quando ne viene eseguito l'override in una classe derivata, scrive una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti.

WriteAsync(Byte[], Int32, Int32)

Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti.

WriteAsync(Byte[], Int32, Int32, CancellationToken)

Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento.

WriteByte(Byte)

Scrive un byte nella posizione corrente del flusso e sposta in avanti di un byte la posizione del flusso.

Implementazioni dell'interfaccia esplicita

IDisposable.Dispose()

Rilascia tutte le risorse usate da Stream.

Metodi di estensione

AsInputStream(Stream)

Converte un flusso gestito in .NET per app di Windows Store in un flusso di input in Windows Runtime.

AsOutputStream(Stream)

Converte un flusso gestito in .NET per app di Windows Store in un flusso di output in Windows Runtime.

AsRandomAccessStream(Stream)

Converte il flusso specificato in un flusso di accesso casuale.

ConfigureAwait(IAsyncDisposable, Boolean)

Consente di configurare la modalità di esecuzione delle espressioni await per le attività restituite da un elemento disposable asincrono.

Si applica a

Vedi anche