Stream Klass

Definition

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

Arv

Object

Stream

Arv

Object

MarshalByRefObject

Stream

Härledda

Microsoft.JScript.COMCharStream

System.Data.OracleClient.OracleBFile

System.Data.OracleClient.OracleLob

System.Data.SqlTypes.SqlFileStream

System.IO.BufferedStream

Mer…

Attribut

SerializableAttribute ComVisibleAttribute

Implementeringar

IDisposable IAsyncDisposable

Exempel

I följande exempel visas hur du använder två FileStream objekt för att asynkront kopiera filerna från en katalog till en annan katalog. Klassen FileStream härleds från Stream klassen. Observera att Click händelsehanteraren för Button kontrollen är markerad med async modifieraren eftersom den anropar en asynkron metod.

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

Kommentarer

Stream är den abstrakta basklassen för alla strömmar. En ström är en abstraktion av en sekvens med byte, till exempel en fil, en in-/utdataenhet, ett kommunikationsrör mellan processer eller en TCP/IP-socket. Klassen Stream och dess härledda klasser ger en allmän vy över dessa olika typer av indata och utdata och isolerar programmeraren från den specifika informationen om operativsystemet och de underliggande enheterna.

Strömmar omfattar tre grundläggande åtgärder:

• Du kan läsa från strömmar. Läsning är överföring av data från en ström till en datastruktur, till exempel en matris med byte.

• Du kan skriva till strömmar. Att skriva är överföringen av data från en datastruktur till en dataström.

• Strömmar kan stödja sökning. Söker refererar till att fråga och ändra den aktuella positionen i en dataström. Sökfunktionen beror på vilken typ av lagringsplats en ström har. Nätverksströmmar har till exempel inget enhetligt koncept för en aktuell position och stöder därför vanligtvis inte sökning.

Några av de vanligaste strömmarna som ärver från Stream är FileStream, och MemoryStream.

Beroende på den underliggande datakällan eller lagringsplatsen kan strömmar endast ha stöd för vissa av dessa funktioner. Du kan fråga en dataström om dess funktioner med hjälp CanReadav egenskaperna Stream , CanWriteoch för CanSeek klassen.

Metoderna Read och Write läser och skriver data i olika format. För strömmar som stöder sökning använder Seek du metoderna och SetLength egenskaperna och PositionLength för att fråga efter och ändra aktuell position och längd för en dataström.

Den här typen implementerar IDisposable gränssnittet. När du har använt typen bör du kassera den på ett direkt eller indirekt sätt. Om du vill ta bort typen direkt anropar du dess Dispose metod i ett try/catch block. Om du vill ta bort det indirekt använder du en språkkonstruktion som using (i C#) eller Using (i Visual Basic). Mer information finns i avsnittet "Använda ett objekt som implementerar IDisposable" i IDisposable gränssnittet.

Om du tar bort ett Stream objekt rensas alla buffrade data och anropar Flush i princip metoden åt dig. Dispose släpper även operativsystemresurser som filhandtag, nätverksanslutningar eller minne som används för intern buffring. Klassen BufferedStream ger möjlighet att omsluta en buffrad ström runt en annan ström för att förbättra läs- och skrivprestanda.

Från och med .NET Framework 4.5 innehåller klassen Stream asynkrona metoder för att förenkla asynkrona åtgärder. En asynkron metod innehåller Async i namnet, till exempel ReadAsync, WriteAsync, CopyToAsyncoch FlushAsync. Med de här metoderna kan du utföra resursintensiva I/O-åtgärder utan att blockera huvudtråden. Den här prestandaöverväganden är särskilt viktig i en Windows 8.x Store-app eller skrivbordsapp där en tidskrävande strömåtgärd kan blockera användargränssnittstråden och få appen att se ut som om den inte fungerar. Asynkrona metoder används tillsammans med nyckelorden async och await i Visual Basic och C#.

När den används i en Windows 8.x Store-app innehåller Stream två tilläggsmetoder: AsInputStream och AsOutputStream. Dessa metoder konverterar ett Stream-objekt till en ström i Windows Runtime. Du kan också konvertera en ström i Windows Runtime till ett Stream-objekt med hjälp av metoderna AsStreamForRead och AsStreamForWrite. Mer information finns i How to: Convert Between .NET Framework Streams and Windows Runtime Streams

Vissa strömimplementeringar utför lokal buffring av underliggande data för att förbättra prestandan. För sådana strömmar kan du använda Flush metoden eller FlushAsync för att rensa eventuella interna buffertar och se till att alla data har skrivits till den underliggande datakällan eller lagringsplatsen.

Om du behöver en ström utan lagringsplats (kallas även en bit-bucket) använder du Null fältet för att hämta en instans av en dataström som är utformad för detta ändamål.

Anteckningar till implementerare

När du implementerar en härledd klass av Streammåste du tillhandahålla implementeringar för Read(Byte[], Int32, Int32) metoderna och Write(Byte[], Int32, Int32) . De asynkrona metoderna ReadAsync(Byte[], Int32, Int32), WriteAsync(Byte[], Int32, Int32)och CopyToAsync(Stream) använder synkrona metoder Read(Byte[], Int32, Int32) och Write(Byte[], Int32, Int32) i deras implementeringar. Därför fungerar dina implementeringar av Read(Byte[], Int32, Int32) och Write(Byte[], Int32, Int32) korrekt med de asynkrona metoderna. Standardimplementeringarna för ReadByte() och WriteByte(Byte) skapar en ny byte-matris med ett element och anropar sedan implementeringarna av Read(Byte[], Int32, Int32) och Write(Byte[], Int32, Int32). När du härleder från Streamrekommenderar vi att du åsidosätter dessa metoder för att få åtkomst till din interna buffert, om du har en, för betydligt bättre prestanda. Du måste också tillhandahålla implementeringar av CanRead, CanSeek, CanWrite, Flush(), Length, Position, Seek(Int64, SeekOrigin)och SetLength(Int64).

Åsidosätt Close() inte metoden, i stället lägger du all rensningslogik Stream i Dispose(Boolean) metoden. Mer information finns i Implementera en avyttringsmetod.

Se även

• FileStream
• MemoryStream
• BufferedStream
• Fil- och ström-I/O
• Så här: Konvertera mellan .NET Framework Streams och Windows Runtime Streams