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 usare due FileStream oggetti per copiare in modo asincrono i file da una directory a un'altra. 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 Stream classe e le 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 dei dispositivi sottostanti.

I flussi implicano tre operazioni fondamentali:

  • È possibile leggere dai flussi. La lettura è il trasferimento di dati da un flusso a 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.

  • I flussi possono supportare la ricerca. La ricerca fa riferimento 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 una posizione corrente e pertanto in genere non supportano la ricerca.

Alcuni dei flussi più comunemente usati che ereditano da Stream sono FileStreame 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 CanReadproprietà , CanWritee CanSeek della Stream classe .

I Read metodi e Write leggono e scrivono dati in un'ampia gamma di formati. Per i flussi che supportano la ricerca, usare i Seek metodi e SetLength e le Position proprietà e Length per eseguire query e modificare la posizione e la lunghezza correnti di un 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 un Stream oggetto scarica tutti i dati memorizzati nel buffer e essenzialmente chiama il metodo per l'utente Flush . Dispose rilascia anche le risorse del sistema operativo, ad esempio handle di file, connessioni di rete o memoria usate per qualsiasi buffering interno. La BufferedStream classe offre la possibilità di eseguire il wrapping di un flusso memorizzato nel buffer intorno a un altro flusso per migliorare le prestazioni di lettura e scrittura.

A partire da .NET Framework 4.5, la Stream classe include metodi asincroni per semplificare le operazioni asincrone. Un metodo asincrono contiene Async nel nome, ad esempio ReadAsync, WriteAsync, CopyToAsynce 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 di Windows 8.x Store o in un'app desktop in cui un'operazione di flusso che richiede molto tempo può bloccare il thread dell'interfaccia utente e rendere l'app come se non funzionasse. I metodi asincroni vengono usati insieme alle async parole chiave e await in Visual Basic e C#.

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

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

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

Note per gli implementatori

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

Non eseguire l'override del Close() metodo , inserire invece tutta la logica di Stream pulizia nel Dispose(Boolean) metodo . 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. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati.

CopyTo(Stream, Int32)

Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati.

CopyToAsync(Stream)

Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati.

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. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati.

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. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati.

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. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati.

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()
Obsoleti.
Obsoleti.
Obsoleti.

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()
Obsoleti.

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()
Obsoleti.

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()
Obsoleti.

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.

ReadAtLeast(Span<Byte>, Int32, Boolean)

Legge almeno un numero minimo di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso in base al numero di byte letti.

ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)

Legge in modo asincrono almeno un numero minimo di byte dal flusso corrente, sposta in avanti la posizione all'interno del flusso 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.

ReadExactly(Byte[], Int32, Int32)

count Legge il numero di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso.

ReadExactly(Span<Byte>)

Legge i byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso fino a quando non viene riempito.buffer

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

Legge in modo asincrono count il numero di byte dal flusso corrente, sposta in avanti la posizione all'interno del flusso e monitora le richieste di annullamento.

ReadExactlyAsync(Memory<Byte>, CancellationToken)

Legge in modo asincrono i byte dal flusso corrente, sposta la posizione all'interno del flusso fino a quando non buffer viene riempito e monitora le richieste di annullamento.

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