Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

BufferedStream-Klasse

 

Fügt eine Pufferung Ebene, um Lese- und Schreibvorgänge auf einen anderen Stream. Diese Klasse kann nicht vererbt werden.

Namespace:   System.IO
Assembly:  mscorlib (in mscorlib.dll)

System.Object
  System.MarshalByRefObject
    System.IO.Stream
      System.IO.BufferedStream

<ComVisibleAttribute(True)>
Public NotInheritable Class BufferedStream
	Inherits Stream

NameBeschreibung
System_CAPS_pubmethodBufferedStream(Stream)

Initialisiert eine neue Instanz der BufferedStream -Klasse mit einer Standardpuffergröße von 4096 Bytes.

System_CAPS_pubmethodBufferedStream(Stream, Int32)

Initialisiert eine neue Instanz der BufferedStream -Klasse mit der angegebenen Puffergröße.

NameBeschreibung
System_CAPS_pubpropertyCanRead

Ruft einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt.(Überschreibt Stream.CanRead.)

System_CAPS_pubpropertyCanSeek

Ruft einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt.(Überschreibt Stream.CanSeek.)

System_CAPS_pubpropertyCanTimeout

Ruft einen Wert ab, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist.(Geerbt von „Stream“.)

System_CAPS_pubpropertyCanWrite

Ruft einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt.(Überschreibt Stream.CanWrite.)

System_CAPS_pubpropertyLength

Ruft die Länge des Streams in Bytes ab.(Überschreibt Stream.Length.)

System_CAPS_pubpropertyPosition

Ruft die Position im aktuellen Stream ab.(Überschreibt Stream.Position.)

System_CAPS_pubpropertyReadTimeout

Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest.(Geerbt von „Stream“.)

System_CAPS_pubpropertyWriteTimeout

Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest.(Geerbt von „Stream“.)

NameBeschreibung
System_CAPS_pubmethodBeginRead(Byte(), Int32, Int32, AsyncCallback, Object)

Beginnt einen asynchronen Lesevorgang. (Verwenden Sie stattdessen ReadAsync. Weitere Informationen finden Sie im Abschnitt "Hinweise".)(Überschreibt Stream.BeginRead(Byte(), Int32, Int32, AsyncCallback, Object).)

System_CAPS_pubmethodBeginWrite(Byte(), Int32, Int32, AsyncCallback, Object)

Beginnt einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync. Weitere Informationen finden Sie im Abschnitt "Hinweise".)(Überschreibt Stream.BeginWrite(Byte(), Int32, Int32, AsyncCallback, Object).)

System_CAPS_pubmethodClose()

Schließt den aktuellen Stream und gibt alle dem aktuellen Stream zugeordneten Ressourcen frei (z. B. Sockets und Dateihandles). Anstatt diese Methode aufzurufen, stellen Sie sicher, dass der Stream ordnungsgemäß freigegeben wird.(Geerbt von „Stream“.)

System_CAPS_pubmethodCopyTo(Stream)

Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom.(Geerbt von „Stream“.)

System_CAPS_pubmethodCopyTo(Stream, Int32)

Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom.(Geerbt von „Stream“.)

System_CAPS_pubmethodCopyToAsync(Stream)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream.(Geerbt von „Stream“.)

System_CAPS_pubmethodCopyToAsync(Stream, Int32)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream.(Geerbt von „Stream“.)

System_CAPS_pubmethodCopyToAsync(Stream, Int32, CancellationToken)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream.(Geerbt von „Stream“.)

System_CAPS_pubmethodCreateObjRef(Type)

Erstellt ein Objekt, das alle relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.(Geerbt von „MarshalByRefObject“.)

System_CAPS_pubmethodDispose()

Gibt alle vom Stream verwendeten Ressourcen frei.(Geerbt von „Stream“.)

System_CAPS_pubmethodEndRead(IAsyncResult)

Wartet, bis der ausstehende asynchrone Lesevorgang abgeschlossen ist. (Verwenden Sie stattdessen ReadAsync. Weitere Informationen finden Sie im Abschnitt "Hinweise".)(Überschreibt Stream.EndRead(IAsyncResult).)

System_CAPS_pubmethodEndWrite(IAsyncResult)

Beendet einen asynchronen Schreibvorgang und blockiert, bis die E/A-Operation abgeschlossen wurde. (Verwenden Sie stattdessen WriteAsync. Weitere Informationen finden Sie im Abschnitt "Hinweise".)(Überschreibt Stream.EndWrite(IAsyncResult).)

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von „Object“.)

System_CAPS_pubmethodFlush()

Löscht sämtliche Puffer für diesen Stream und bewirkt, dass alle gepufferten Daten an das zugrunde liegende Gerät geschrieben werden.(Überschreibt Stream.Flush().)

System_CAPS_pubmethodFlushAsync()

Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät.(Geerbt von „Stream“.)

System_CAPS_pubmethodFlushAsync(CancellationToken)

Löscht alle Puffer für diesen Stream asynchron, veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen.(Überschreibt Stream.FlushAsync(CancellationToken).)

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von „Object“.)

System_CAPS_pubmethodGetLifetimeService()

Ruft die aktuellen Service-Objekt, das die Lebensdauerrichtlinien für diese Instanz steuert.(Geerbt von „MarshalByRefObject“.)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodInitializeLifetimeService()

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinien für diese Instanz ab.(Geerbt von „MarshalByRefObject“.)

System_CAPS_pubmethodRead(Byte(), Int32, Int32)

Kopiert Bytes aus dem aktuellen gepufferten Stream in ein Array.(Überschreibt Stream.Read(Byte(), Int32, Int32).)

System_CAPS_pubmethodReadAsync(Byte(), Int32, Int32)

Liest eine Bytesequenz asynchron aus dem aktuellen Stream und setzt die Position in diesem Stream um die Anzahl der gelesenen Bytes nach vorn.(Geerbt von „Stream“.)

System_CAPS_pubmethodReadAsync(Byte(), Int32, Int32, CancellationToken)

Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen.(Überschreibt Stream.ReadAsync(Byte(), Int32, Int32, CancellationToken).)

System_CAPS_pubmethodReadByte()

Liest ein Byte aus dem zugrunde liegenden Stream und gibt das Byte, umgewandelt in ein int, oder gibt-1 zurück, wenn das Ende des Streams erreicht.(Überschreibt Stream.ReadByte().)

System_CAPS_pubmethodSeek(Int64, SeekOrigin)

Legt die Position im aktuellen gepufferten Stream fest.(Überschreibt Stream.Seek(Int64, SeekOrigin).)

System_CAPS_pubmethodSetLength(Int64)

Legt die Länge des gepufferten Streams fest.(Überschreibt Stream.SetLength(Int64).)

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

System_CAPS_pubmethodWrite(Byte(), Int32, Int32)

Kopiert Bytes in den gepufferten Stream und erhöht die aktuelle Position im gepufferten Stream um die Anzahl der geschriebenen Bytes.(Überschreibt Stream.Write(Byte(), Int32, Int32).)

System_CAPS_pubmethodWriteAsync(Byte(), Int32, Int32)

Schreibt eine Bytesequenz asynchron in den aktuellen Stream und setzt die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes nach vorn.(Geerbt von „Stream“.)

System_CAPS_pubmethodWriteAsync(Byte(), Int32, Int32, CancellationToken)

Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen.(Überschreibt Stream.WriteAsync(Byte(), Int32, Int32, CancellationToken).)

System_CAPS_pubmethodWriteByte(Byte)

Schreibt ein Byte an die aktuelle Position im gepufferten Stream.(Überschreibt Stream.WriteByte(Byte).)

Ein Puffer ist, einen Block von Bytes im Speicher zum Zwischenspeichern von Daten, wodurch die Anzahl der Aufrufe an das Betriebssystem verwendet wird. Puffer verbessern, lesen und schreiben die Leistung. Ein Puffer kann für entweder lesen oder schreiben, aber nicht beides gleichzeitig verwendet werden. Die Read und Write Methoden der BufferedStream verwalten den Puffer automatisch.

System_CAPS_importantWichtig

Dieser Typ implementiert die IDisposable Schnittstelle. Wenn Sie mit dem Datentyp haben, sollten Sie es entweder direkt oder indirekt freigeben. Damit des Typs direkt freigegeben werden, rufen Sie seine Dispose -Methode in eine try/catch Block. Verwenden, um es indirekt freigegeben werden, z. B. ein Sprachkonstrukt using (in c#) oder Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt "Verwenden eines Objekts, die implementiert IDisposable" in der IDisposable Thema zur Schnittstelle.

BufferedStream kann auf bestimmte Arten von Streams verfasst werden. Es bietet die Implementierung für das Lesen und Schreiben von Bytes in einer zugrunde liegenden Datenquelle oder das Repository. Mit BinaryReader und BinaryWriter zum Lesen und Schreiben anderer Datentypen. BufferedStream Dient zum verhindern, dass des Puffers Eingabe und Ausgabe verlangsamt, wenn der Puffer nicht benötigt wird. Wenn Sie immer lesen und dann größer als die Größe des internen Puffers schreiben BufferedStream möglicherweise nicht den internen Puffer selbst zuweisen. BufferedStream puffert auch Lese- und Schreibvorgänge in einem freigegebenen Puffer. Es wird vorausgesetzt, dass Sie fast immer werden eine Reihe von Lese- oder Schreibvorgänge ausführen, jedoch selten zwischen diesen beiden wechseln.

Die folgenden Codebeispiele zeigen, wie mithilfe der BufferedStream Klasse über die NetworkStream Klasse zur Steigerung der Leistung von bestimmten e/a-Vorgängen. Starten Sie den Server vor dem Starten des Clients auf einem Remotecomputer befindet. Geben Sie den Namen des Remotecomputers als Befehlszeilenargument, beim Starten des Clients. Verändern der dataArraySize und streamBufferSize Konstanten, um ihre Auswirkung auf die Leistung anzuzeigen.

Das erste Beispiel zeigt den Code, der auf dem Client ausgeführt wird, und das zweite Beispiel zeigt den Code, der auf dem Server ausgeführt wird.

Beispiel 1: Code, der auf dem Client ausgeführt wird.

' Compile using /r:System.dll.
Imports Microsoft.VisualBasic
Imports System
Imports System.IO
Imports System.Globalization
Imports System.Net
Imports System.Net.Sockets

Public Class Client 

    Const dataArraySize As Integer    =   100
    Const streamBufferSize As Integer =  1000
    Const numberOfLoops As Integer    = 10000

    Shared Sub Main(args As String()) 

        ' Check that an argument was specified when the 
        ' program was invoked.
        If args.Length = 0 Then
            Console.WriteLine("Error: The name of the host " & _
                "computer must be specified when the program " & _ 
                "is invoked.")
            Return
        End If

        Dim remoteName As String = args(0)

        ' Create the underlying socket and connect to the server.
        Dim clientSocket As New Socket(AddressFamily.InterNetwork, _
            SocketType.Stream, ProtocolType.Tcp)

        clientSocket.Connect(New IPEndPoint( _
            Dns.Resolve(remoteName).AddressList(0), 1800))

        Console.WriteLine("Client is connected." & vbCrLf)

        ' Create a NetworkStream that owns clientSocket and then 
        ' create a BufferedStream on top of the NetworkStream.
        Dim netStream As New NetworkStream(clientSocket, True)
        Dim bufStream As New _
            BufferedStream(netStream, streamBufferSize)

        Try
            ' Check whether the underlying stream supports seeking.
            If bufStream.CanSeek Then
                Console.WriteLine("NetworkStream supports" & _
                    "seeking." & vbCrLf)
            Else
                Console.WriteLine("NetworkStream does not " & _
                    "support seeking." & vbCrLf)
            End If

            ' Send and receive data.
            If bufStream.CanWrite Then
                SendData(netStream, bufStream)
            End If            
            If bufStream.CanRead Then
                ReceiveData(netStream, bufStream)
            End If
        Finally

            ' When bufStream is closed, netStream is in turn 
            ' closed, which in turn shuts down the connection 
            ' and closes clientSocket.
            Console.WriteLine(vbCrLf & "Shutting down the connection.")
            bufStream.Close()
        End Try
    End Sub

    Shared Sub SendData(netStream As Stream, bufStream As Stream)

        Dim startTime As DateTime 
        Dim networkTime As Double, bufferedTime As Double 

        ' Create random data to send to the server.
        Dim dataToSend(dataArraySize - 1) As Byte
        Dim randomGenerator As New Random()
        randomGenerator.NextBytes(dataToSend)

        ' Send the data using the NetworkStream.
        Console.WriteLine("Sending data using NetworkStream.")
        startTime = DateTime.Now
        For i As Integer = 1 To numberOfLoops
            netStream.Write(dataToSend, 0, dataToSend.Length)
        Next i
        networkTime = DateTime.Now.Subtract(startTime).TotalSeconds
        Console.WriteLine("{0} bytes sent in {1} seconds." & vbCrLf, _
            numberOfLoops * dataToSend.Length, _
            networkTime.ToString("F1"))

        ' Send the data using the BufferedStream.
        Console.WriteLine("Sending data using BufferedStream.")
        startTime = DateTime.Now
        For i As Integer = 1 To numberOfLoops
            bufStream.Write(dataToSend, 0, dataToSend.Length)
        Next i

        bufStream.Flush()
        bufferedTime = DateTime.Now.Subtract(startTime).TotalSeconds
        Console.WriteLine("{0} bytes sent In {1} seconds." & vbCrLf, _
            numberOfLoops * dataToSend.Length, _
            bufferedTime.ToString("F1"))

        ' Print the ratio of write times.
        Console.Write("Sending data using the buffered " & _
            "network stream was {0}", _
            (networkTime/bufferedTime).ToString("P0"))
        If bufferedTime < networkTime Then
            Console.Write(" faster")
        Else
            Console.Write(" slower")
        End If
        Console.WriteLine(" than using the network stream alone.")
    End Sub

    Shared Sub ReceiveData(netStream As Stream, bufStream As Stream)

        Dim startTime As DateTime 
        Dim networkTime As Double, bufferedTime As Double = 0

        Dim bytesReceived As Integer = 0
        Dim receivedData(dataArraySize - 1) As Byte

        ' Receive data using the NetworkStream.
        Console.WriteLine("Receiving data using NetworkStream.")
        startTime = DateTime.Now
        While bytesReceived < numberOfLoops * receivedData.Length
            bytesReceived += netStream.Read( _
                receivedData, 0, receivedData.Length)
        End While
        networkTime = DateTime.Now.Subtract(startTime).TotalSeconds
        Console.WriteLine("{0} bytes received in {1} " & _
            "seconds." & vbCrLf, _
            bytesReceived.ToString(), _
            networkTime.ToString("F1"))

        ' Receive data using the BufferedStream.
        Console.WriteLine("Receiving data using BufferedStream.")
        bytesReceived = 0
        startTime = DateTime.Now

        Dim numBytesToRead As Integer = receivedData.Length
        Dim n As Integer
        Do While numBytesToRead > 0

            'Read my return anything from 0 to numBytesToRead
            n = bufStream.Read(receivedData, 0, receivedData.Length)
            'The end of the file is reached.
            If n = 0 Then
                Exit Do
            End If

            bytesReceived += n
            numBytesToRead -= n
        Loop

        bufferedTime = DateTime.Now.Subtract(startTime).TotalSeconds
        Console.WriteLine("{0} bytes received in {1} " & _
            "seconds." & vbCrLf, _
            bytesReceived.ToString(), _
            bufferedTime.ToString("F1"))

        ' Print the ratio of read times.
        Console.Write("Receiving data using the buffered " & _
            "network stream was {0}", _
            (networkTime/bufferedTime).ToString("P0"))
        If bufferedTime < networkTime Then
            Console.Write(" faster")
        Else
            Console.Write(" slower")
        End If
        Console.WriteLine(" than using the network stream alone.")
    End Sub
End Class

Beispiel 2: Code, der auf dem Server ausgeführt wird.

' Compile using /r:System.dll.
Imports Microsoft.VisualBasic
Imports System
Imports System.Net
Imports System.Net.Sockets

Public Class Server 

    Shared Sub Main() 

        ' This is a Windows Sockets 2 error code.
        Const WSAETIMEDOUT As Integer = 10060

        Dim serverSocket As Socket 
        Dim bytesReceived As Integer
        Dim totalReceived As Integer = 0
        Dim receivedData(2000000-1) As Byte

        ' Create random data to send to the client.
        Dim dataToSend(2000000-1) As Byte
        Dim randomGenerator As New Random()
        randomGenerator.NextBytes(dataToSend)

        Dim ipAddress As IPAddress = _
            Dns.Resolve(Dns.GetHostName()).AddressList(0)

        Dim ipEndpoint As New IPEndPoint(ipAddress, 1800)

        ' Create a socket and listen for incoming connections.
        Dim listenSocket As New Socket(AddressFamily.InterNetwork, _
            SocketType.Stream, ProtocolType.Tcp)

        Try
            listenSocket.Bind(ipEndpoint)
            listenSocket.Listen(1)

            ' Accept a connection and create a socket to handle it.
            serverSocket = listenSocket.Accept()
            Console.WriteLine("Server is connected." & vbCrLf)
        Finally
            listenSocket.Close()
        End Try

        Try
            ' Send data to the client.
            Console.Write("Sending data ... ")
            Dim bytesSent As Integer = serverSocket.Send( _
                dataToSend, 0, dataToSend.Length, SocketFlags.None)
            Console.WriteLine("{0} bytes sent." & vbCrLf, _
                bytesSent.ToString())

            ' Set the timeout for receiving data to 2 seconds.
            serverSocket.SetSocketOption(SocketOptionLevel.Socket, _
                SocketOptionName.ReceiveTimeout, 2000)

            ' Receive data from the client.
            Console.Write("Receiving data ... ")
            Try
                Do
                    bytesReceived = serverSocket.Receive( _
                        receivedData, 0, receivedData.Length, _
                        SocketFlags.None)
                    totalReceived += bytesReceived
                Loop While bytesReceived <> 0
            Catch e As SocketException
                If(e.ErrorCode = WSAETIMEDOUT)

                    ' Data was not received within the given time.
                    ' Assume that the transmission has ended.
                Else
                    Console.WriteLine("{0}: {1}" & vbCrLf, _
                        e.GetType().Name, e.Message)
                End If
            Finally
                Console.WriteLine("{0} bytes received." & vbCrLf, _
                    totalReceived.ToString())
            End Try
        Finally
            serverSocket.Shutdown(SocketShutdown.Both)
            Console.WriteLine("Connection shut down.")
            serverSocket.Close()
        End Try

    End Sub
End Class

.NET Framework
Verfügbar seit 1.1

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: