Stream Klas

Definitie

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

Overname

Object

Stream

Overname

Object

MarshalByRefObject

Stream

Afgeleid

Microsoft.JScript.COMCharStream

System.Data.OracleClient.OracleBFile

System.Data.OracleClient.OracleLob

System.Data.SqlTypes.SqlFileStream

System.IO.BufferedStream

Meer…

Kenmerken

SerializableAttribute ComVisibleAttribute

Implementeringen

IDisposable IAsyncDisposable

Voorbeelden

In het volgende voorbeeld ziet u hoe u twee FileStream objecten gebruikt om de bestanden asynchroon te kopiëren van de ene map naar een andere map. De FileStream klasse is afgeleid van de Stream klasse. Merk op dat de Click gebeurtenis-handler voor het Button besturingselement is gemarkeerd met de async modifier omdat deze een asynchrone methode aanroept.

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

Opmerkingen

Stream is de abstracte basisklasse van alle streams. Een stroom is een abstractie van een reeks bytes, zoals een bestand, een invoer-/uitvoerapparaat, een communicatiepijp tussen processen of een TCP/IP-socket. De Stream klasse en de afgeleide klassen bieden een algemene weergave van deze verschillende typen invoer en uitvoer, en isoleren de programmeur van de specifieke details van het besturingssysteem en de onderliggende apparaten.

Streams omvatten drie fundamentele bewerkingen:

• U kunt lezen uit streams. Lezen is de overdracht van gegevens uit een stroom naar een gegevensstructuur, zoals een matrix van bytes.

• U kunt schrijven naar streams. Schrijven is de overdracht van gegevens uit een gegevensstructuur in een stroom.

• Streams kunnen zoeken ondersteunen. Het zoeken naar query's en het wijzigen van de huidige positie binnen een stroom. De functie Zoeken is afhankelijk van het soort back-uparchief dat een stream heeft. Netwerkstromen hebben bijvoorbeeld geen geïntegreerd concept van een huidige positie en bieden daarom meestal geen ondersteuning voor zoeken.

Enkele van de meestgebruikte streams waaruit ze overnemen Stream , zijn FileStream, en MemoryStream.

Afhankelijk van de onderliggende gegevensbron of opslagplaats kunnen streams slechts enkele van deze mogelijkheden ondersteunen. U kunt een stream opvragen voor de mogelijkheden ervan met behulp van de CanRead, CanWriteen CanSeek eigenschappen van de Stream klasse.

De Read en Write methoden lezen en schrijven gegevens in verschillende indelingen. Voor streams die ondersteuning bieden voor het zoeken, gebruiken van de Seek en SetLength methoden en eigenschappen PositionLength om de huidige positie en lengte van een stroom op te vragen en te wijzigen.

Met dit type wordt de IDisposable interface geïmplementeerd. Wanneer u klaar bent met het gebruik van het type, moet u het direct of indirect verwijderen. Als u het type rechtstreeks wilt verwijderen, roept u de Dispose methode aan in een try/catch blok. Als u deze indirect wilt verwijderen, gebruikt u een taalconstructie zoals using (in C#) of Using (in Visual Basic). Zie de sectie 'Using an Object that Implements IDisposable' (Een object gebruiken dat IDisposable implementeert) in het IDisposable interfaceonderwerp voor meer informatie.

Als u een Stream object opstelt, worden alle gebufferde gegevens leeggemaakt en wordt de Flush methode voor u in wezen aangeroepen. Dispose publiceert ook besturingssysteemresources, zoals bestandsingangen, netwerkverbindingen of geheugen die worden gebruikt voor interne buffering. De BufferedStream klasse biedt de mogelijkheid om een gebufferde stroom rond een andere stroom te verpakken om de lees- en schrijfprestaties te verbeteren.

Vanaf het .NET Framework 4.5 bevat de klasse Stream asynchrone methoden om asynchrone bewerkingen te vereenvoudigen. Een asynchrone methode bevat Async de naam, zoals ReadAsync, WriteAsyncen CopyToAsyncFlushAsync. Met deze methoden kunt u resource-intensieve I/O-bewerkingen uitvoeren zonder de hoofdthread te blokkeren. Deze prestatieoverweging is met name belangrijk in een Windows 8.x Store-app of -desktop-app, waarbij een tijdrovende streambewerking de UI-thread kan blokkeren en uw app kan weergeven alsof deze niet werkt. De asynchrone methoden worden gebruikt in combinatie met de trefwoorden async en await in Visual Basic en C#.

Wanneer Stream wordt gebruikt in een Windows 8.x Store-app, zijn er twee uitbreidingsmethoden opgenomen: AsInputStream en AsOutputStream. Met deze methoden wordt een Stream-object geconverteerd naar een stroom in de Windows Runtime. U kunt ook een stroom in de Windows Runtime converteren naar een Stream-object met behulp van de methoden AsStreamForRead en AsStreamForWrite. Zie How to: Convert Between .NET Framework Streams and Windows Runtime Streams voor meer informatie.

Sommige stream-implementaties voeren lokale buffering van de onderliggende gegevens uit om de prestaties te verbeteren. Voor dergelijke streams kunt u de Flush of FlushAsync methode gebruiken om interne buffers te wissen en ervoor te zorgen dat alle gegevens naar de onderliggende gegevensbron of opslagplaats zijn geschreven.

Als u een stream zonder back-uparchief nodig hebt (ook wel een bit bucket genoemd), gebruikt u het Null veld om een exemplaar van een stream op te halen dat voor dit doel is ontworpen.

Notities voor uitvoerders

Wanneer u een afgeleide klasse Streamimplementeert, moet u implementaties voor de Read(Byte[], Int32, Int32) en Write(Byte[], Int32, Int32) methoden opgeven. De asynchrone methoden ReadAsync(Byte[], Int32, Int32)en WriteAsync(Byte[], Int32, Int32)CopyToAsync(Stream) gebruiken de synchrone methoden Read(Byte[], Int32, Int32) en Write(Byte[], Int32, Int32) in hun implementaties. Daarom werken uw implementaties van Read(Byte[], Int32, Int32) en Write(Byte[], Int32, Int32) werken ze correct met de asynchrone methoden. De standaard implementaties van en WriteByte(Byte) het maken van ReadByte() een nieuwe bytematrix met één element en roepen vervolgens uw implementaties van Read(Byte[], Int32, Int32) en Write(Byte[], Int32, Int32). Wanneer u afgeleid bent van Stream, raden we u aan deze methoden te overschrijven om toegang te krijgen tot uw interne buffer, als u er een hebt, voor aanzienlijk betere prestaties. U moet ook implementaties van , , , , Flush(), Length, , Position, en Seek(Int64, SeekOrigin). SetLength(Int64). CanWriteCanSeekCanRead

Overschrijf in plaats daarvan niet alle Close()Stream opschoonlogica in de Dispose(Boolean) methode. Zie Een verwijderingsmethode implementeren voor meer informatie.

Zie ook

• FileStream
• MemoryStream
• BufferedStream
• Bestands- en Stream-I/O
• Hoe to: Converteren tussen .NET Framework-streams en Windows Runtime streams