Condividi tramite

Stream Classe

  • Riferimento

Definizione

Spazio dei nomi:
System.IO
Assembly:
System.IO.dll
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll
Origine:
Stream.cs
Origine:
Stream.cs
Origine:
Stream.cs

Fornisce una visualizzazione generica di una sequenza di byte. Si tratta di una classe astratta.

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à
Object
Stream
Ereditarietà
Object
MarshalByRefObject
Stream
Derivato
Attributi
SerializableAttribute ComVisibleAttribute
Implementazioni
IDisposable IAsyncDisposable

Esempio

Nell'esempio seguente viene illustrato come utilizzare due oggetti FileStream 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 classe Stream 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 dei dispositivi sottostanti.

I flussi prevedono 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.

  • 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 usati più comunemente 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 query su un flusso per individuare le relative funzionalità usando le proprietà CanRead, CanWritee CanSeek della classe Stream.

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

Questo tipo implementa l'interfaccia IDisposable. Al termine dell'uso del tipo, è necessario eliminarlo direttamente o indirettamente. Per eliminare direttamente il tipo, chiamare il metodo Dispose in un blocco try/catch. Per eliminarlo indirettamente, usare un costrutto del linguaggio, 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 oggetto Stream scarica tutti i dati memorizzati nel buffer e chiama essenzialmente il metodo Flush. Dispose rilascia anche risorse del sistema operativo, ad esempio handle di file, connessioni di rete o memoria usati per qualsiasi buffering interno. La classe BufferedStream 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 classe Stream 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 dispendiosa in termini di tempo può bloccare il thread dell'interfaccia utente e rendere l'app come se non funzionasse. I metodi asincroni vengono usati insieme alle parole chiave async 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 oggetto Stream in un flusso in Windows Runtime. Puoi anche convertire un flusso in Windows Runtime in un oggetto Stream usando i metodi AsStreamForRead e AsStreamForWrite. Per altre informazioni, vedere Procedura: Eseguire la conversione tra flussi .NET Framework e flussi di Windows Runtime

Alcune implementazioni del flusso eseguono il buffering locale dei dati sottostanti per migliorare le prestazioni. Per questi flussi, è possibile usare il metodo Flush 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 campo Null 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 metodi Read(Byte[], Int32, Int32) e Write(Byte[], Int32, Int32). I metodi asincroni ReadAsync(Byte[], Int32, Int32), WriteAsync(Byte[], Int32, Int32)e CopyToAsync(Stream) usano i metodi sincroni Read(Byte[], Int32, Int32) e Write(Byte[], Int32, Int32) nelle implementazioni. Pertanto, 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) creare una nuova matrice di byte a singolo elemento e quindi chiamare 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. È inoltre necessario fornire implementazioni di CanRead, CanSeek, CanWrite, Flush(), Length, Position, Seek(Int64, SeekOrigin)e SetLength(Int64).

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

Costruttori

Stream()

Inizializza una nuova istanza della classe Stream.

Campi

Null

Un Stream senza archivio di backup.

Proprietà

CanRead

In caso di override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la lettura.
CanSeek

In caso di 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 può verificarsi un timeout.
CanWrite

In caso di override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la scrittura.
Length

Quando sottoposto a override in una classe derivata, ottiene la lunghezza in byte del flusso.
Position

Quando sottoposto a override in una classe derivata, ottiene o imposta la posizione all'interno del flusso corrente.
ReadTimeout

Ottiene o imposta un valore, espresso in millisecondi, che determina per quanto tempo il flusso tenterà di leggere prima del timeout.
WriteTimeout

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

Metodi

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

Avvia un'operazione di lettura asincrona. Prendere invece in considerazione l'uso di ReadAsync(Byte[], Int32, Int32).
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Avvia un'operazione di scrittura asincrona. Prendere invece in considerazione l'uso di WriteAsync(Byte[], Int32, Int32).
Close()

Chiude il flusso corrente e rilascia tutte le risorse (ad esempio socket e handle di file) associate al flusso corrente. Invece di 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 i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione del 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 i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione del 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 del buffer e un token di annullamento specificati. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati.
CreateObjRef(Type)

Crea un oggetto che contiene tutte le informazioni pertinenti necessarie per generare un proxy utilizzato per comunicare con un oggetto remoto.

(Ereditato da MarshalByRefObject)
CreateWaitHandle()
Obsoleti.
Obsoleti.
Obsoleti.

Alloca un oggetto WaitHandle.
Dispose()

Rilascia tutte le risorse usate dal Stream.
Dispose(Boolean)

Rilascia le risorse non gestite usate dal Stream e, facoltativamente, rilascia le risorse gestite.
DisposeAsync()

Rilascia in modo asincrono le risorse non gestite usate dal Stream.
EndRead(IAsyncResult)

Attende il completamento della lettura asincrona in sospeso. Prendere invece in considerazione l'uso di ReadAsync(Byte[], Int32, Int32).
EndWrite(IAsyncResult)

Termina un'operazione di scrittura asincrona. Prendere invece in considerazione l'uso di WriteAsync(Byte[], Int32, Int32).
Equals(Object)

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

(Ereditato da Object)
Flush()

Quando sottoposto a override in una classe derivata, cancella tutti i buffer per questo flusso e fa in modo che tutti i dati memorizzati nel buffer vengano scritti nel dispositivo sottostante.
FlushAsync()

Cancella in modo asincrono tutti i buffer per questo flusso e determina la scrittura di tutti i dati memorizzati nel buffer nel dispositivo sottostante.
FlushAsync(CancellationToken)

Cancella in modo asincrono tutti i buffer per questo flusso, determina la scrittura di tutti i dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento.
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetLifetimeService()
Obsoleti.

Recupera l'oggetto servizio di durata corrente che controlla i criteri di durata per questa istanza.

(Ereditato da MarshalByRefObject)
GetType()

Ottiene il 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 del Objectcorrente.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia superficiale dell'oggetto MarshalByRefObject corrente.

(Ereditato da MarshalByRefObject)
ObjectInvariant()
Obsoleti.

Fornisce il supporto per un Contract.
Read(Byte[], Int32, Int32)

Quando sottoposto a override in una classe derivata, legge una sequenza di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso in base al numero di byte letti.
Read(Span<Byte>)

Quando sottoposto a override in una classe derivata, legge una sequenza di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso in base al numero di byte letti.
ReadAsync(Byte[], Int32, Int32)

Legge in modo asincrono una sequenza di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso in base al numero di byte letti.
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Legge in modo asincrono una sequenza 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.
ReadAsync(Memory<Byte>, CancellationToken)

Legge in modo asincrono una sequenza 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.
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 all'interno del flusso di un byte oppure restituisce -1 se alla fine del flusso.
ReadExactly(Byte[], Int32, Int32)

Legge count 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 il buffer non viene riempito.
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)

Legge in modo asincrono count 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 il buffer non viene riempito e monitora le richieste di annullamento.
Seek(Int64, SeekOrigin)

Quando sottoposto a override in una classe derivata, imposta la posizione all'interno del flusso corrente.
SetLength(Int64)

Quando sottoposto a override in una classe derivata, imposta la lunghezza del flusso corrente.
Synchronized(Stream)

Crea un wrapper thread-safe (sincronizzato) intorno all'oggetto Stream specificato.
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

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

Convalida gli argomenti forniti per leggere e scrivere metodi in Stream.
ValidateCopyToArguments(Stream, Int32)

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

Quando sottoposto a override in una classe derivata, scrive una sequenza di byte nel flusso corrente e sposta in avanti la posizione corrente all'interno del flusso in base al numero di byte scritti.
Write(ReadOnlySpan<Byte>)

Quando sottoposto a override in una classe derivata, scrive una sequenza di byte nel flusso corrente e sposta in avanti la posizione corrente all'interno del flusso in base al numero di byte scritti.
WriteAsync(Byte[], Int32, Int32)

Scrive in modo asincrono una sequenza di byte nel flusso corrente e sposta in avanti la posizione corrente all'interno del flusso in base al numero di byte scritti.
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Scrive in modo asincrono una sequenza di byte nel flusso corrente, sposta in avanti la posizione corrente all'interno del flusso 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, sposta in avanti la posizione corrente all'interno del flusso in base al numero di byte scritti e monitora le richieste di annullamento.
WriteByte(Byte)

Scrive un byte nella posizione corrente nel flusso e sposta in avanti la posizione all'interno del flusso di un byte.

Implementazioni dell'interfaccia esplicita

IDisposable.Dispose()

Rilascia tutte le risorse usate dal Stream.

Metodi di estensione

CopyToAsync(Stream, PipeWriter, CancellationToken)

Legge in modo asincrono i byte dal Stream e li scrive nel PipeWriterspecificato usando un token di annullamento.
AsInputStream(Stream)

Converte un flusso gestito nelle app .NET per Windows Store in un flusso di input in Windows Runtime.
AsOutputStream(Stream)

Converte un flusso gestito nelle app .NET per 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)

Configura il modo in cui verranno eseguite le attese nelle attività restituite da un oggetto eliminabile asincrono.

Si applica a

Vedi anche