Stream Classe

Definizione

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

Microsoft.JScript.COMCharStream

System.Data.OracleClient.OracleBFile

System.Data.OracleClient.OracleLob

System.Data.SqlTypes.SqlFileStream

System.IO.BufferedStream

Altro…

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

Campi

Proprietà

Metodi

Implementazioni dell'interfaccia esplicita

Metodi di estensione

Si applica a

Vedi anche

• FileStream
• MemoryStream
• BufferedStream
• di I/O di flusso e file
• Procedura: Eseguire la conversione tra flussi .NET Framework e flussi di Windows Runtime