(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

BufferedStream-Klasse

Fügt eine Pufferungsschicht für Lese- und Schreibvorgänge in einem anderen Stream hinzu. Die Klasse erlaubt keine Vererbung.

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

[ComVisibleAttribute(true)]
public sealed class BufferedStream : Stream

Der BufferedStream-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche MethodeBufferedStream(Stream)Initialisiert eine neue Instanz der BufferedStream-Klasse mit einer Standardpuffergröße von 4096 Bytes.
Öffentliche MethodeBufferedStream(Stream, Int32)Initialisiert eine neue Instanz der BufferedStream-Klasse mit der angegebenen Puffergröße.
Zum Seitenanfang

  NameBeschreibung
Öffentliche EigenschaftCanReadRuft einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. (Überschreibt Stream.CanRead.)
Öffentliche EigenschaftCanSeekRuft einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. (Überschreibt Stream.CanSeek.)
Öffentliche EigenschaftCanTimeoutRuft einen Wert ab, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. (Von Stream geerbt.)
Öffentliche EigenschaftCanWriteRuft einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. (Überschreibt Stream.CanWrite.)
Öffentliche EigenschaftLengthRuft die Länge des Streams in Bytes ab. (Überschreibt Stream.Length.)
Öffentliche EigenschaftPositionRuft die Position im aktuellen Stream ab. (Überschreibt Stream.Position.)
Öffentliche EigenschaftReadTimeoutRuft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. (Von Stream geerbt.)
Öffentliche EigenschaftWriteTimeoutRuft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. (Von Stream geerbt.)
Zum Seitenanfang

  NameBeschreibung
Öffentliche MethodeBeginReadBeginnt einen asynchronen Lesevorgang. (Verwenden Sie stattdessen ReadAsync. Weitere Informationen finden Sie im Abschnitt "Hinweise".) (Überschreibt Stream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).)

In .NET Framework Client Profile 4 wird dieser Member von Stream geerbt.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
Öffentliche MethodeBeginWriteBeginnt einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync. Weitere Informationen finden Sie im Abschnitt "Hinweise".) (Überschreibt Stream.BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).)

In .NET Framework Client Profile 4 wird dieser Member von Stream geerbt.BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Öffentliche MethodeCloseSchließ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. (Von Stream geerbt.)
Öffentliche MethodeCopyTo(Stream)Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. (Von Stream geerbt.)
Öffentliche MethodeCopyTo(Stream, Int32)Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom. (Von Stream geerbt.)
Öffentliche MethodeCopyToAsync(Stream)Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. (Von Stream geerbt.)
Öffentliche MethodeCopyToAsync(Stream, Int32)Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream. (Von Stream geerbt.)
Öffentliche MethodeCopyToAsync(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. (Von Stream geerbt.)
Öffentliche MethodeCreateObjRefErstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeDispose()Gibt sämtliche vom Stream verwendeten Ressourcen frei. (Von Stream geerbt.)
Öffentliche MethodeEndReadWartet, bis der ausstehende asynchrone Lesevorgang abgeschlossen ist. (Verwenden Sie stattdessen ReadAsync. Weitere Informationen finden Sie im Abschnitt "Hinweise".) (Überschreibt Stream.EndRead(IAsyncResult).)

In .NET Framework Client Profile 4 wird dieser Member von Stream geerbt.EndRead(IAsyncResult).
Öffentliche MethodeEndWriteBeendet 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).)

In .NET Framework Client Profile 4 wird dieser Member von Stream geerbt.EndWrite(IAsyncResult).
Öffentliche MethodeEquals(Object)Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist. (Von Object geerbt.)
Öffentliche MethodeFlushLöscht sämtliche Puffer für diesen Stream und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. (Überschreibt Stream.Flush().)
Öffentliche MethodeFlushAsync()Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. (Von Stream geerbt.)
Öffentliche MethodeFlushAsync(CancellationToken)Löscht alle Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen. (Überschreibt Stream.FlushAsync(CancellationToken).)
Öffentliche MethodeGetHashCodeFungiert als die Standardhashfunktion. (Von Object geerbt.)
Öffentliche MethodeGetLifetimeServiceRuft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeInitializeLifetimeServiceRuft ein Lebensdauerdienstobjekt ab, mit dem die Lebensdauerrichtlinien für diese Instanz gesteuert werden können. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeReadKopiert Bytes aus dem aktuellen gepufferten Stream in ein Array. (Überschreibt Stream.Read(Byte[], Int32, Int32).)
Öffentliche MethodeReadAsync(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. (Von Stream geerbt.)
Öffentliche MethodeReadAsync(Byte[], Int32, Int32, CancellationToken)Liest eine Folge von Bytes asynchron aus aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. (Überschreibt Stream.ReadAsync(Byte[], Int32, Int32, CancellationToken).)
Öffentliche MethodeReadByteLiest ein Byte aus dem zugrunde liegenden Stream und gibt dieses in ein int umgewandelt zurück, bzw. wird -1 zurückgegeben, wenn das Ende des Streams erreicht ist. (Überschreibt Stream.ReadByte().)
Öffentliche MethodeSeekLegt die Position im aktuellen gepufferten Stream fest. (Überschreibt Stream.Seek(Int64, SeekOrigin).)
Öffentliche MethodeSetLengthLegt die Länge des gepufferten Streams fest. (Überschreibt Stream.SetLength(Int64).)
Öffentliche MethodeToStringGibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Von Object geerbt.)
Öffentliche MethodeWriteKopiert Bytes in den gepufferten Stream und verschiebt die aktuelle Position im gepufferten Stream um die Anzahl der geschriebenen Bytes. (Überschreibt Stream.Write(Byte[], Int32, Int32).)
Öffentliche MethodeWriteAsync(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. (Von Stream geerbt.)
Öffentliche MethodeWriteAsync(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).)
Öffentliche MethodeWriteByteSchreibt ein Byte an die aktuelle Position im gepufferten Stream. (Überschreibt Stream.WriteByte(Byte).)
Zum Seitenanfang

Ein Puffer ist ein für die Zwischenspeicherung von Daten reservierter Byteblock im Arbeitsspeicher, durch den die Anzahl der Aufrufe an das Betriebssystem verringert wird. Puffer erhöhen die Lese- und Schreibleistung. Puffer können für Lese- und Schreibvorgänge verwendet werden, jedoch nicht für beides gleichzeitig. Die Read-Methode und die Write-Methode von BufferedStream verwalten den Puffer automatisch.

Wichtiger HinweisWichtig

Dieser Typ implementiert die IDisposable-Schnittstelle. Wenn die Verwendung des Typs haben, sollten Sie diesen direkt oder indirekt entweder freigeben. Um den Typ direkt zu löschen, rufen Sie die Dispose-Methode in einem try/catch-Block auf. So zeigen ihn indirekt freizugeben, verwenden Sie ein Sprachkonstrukt wie using (in C#) oder Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt "Verwenden eines Objekts, das Abschnitt IDisposable" im IDisposable-Schnittstellenthema implementiert.

BufferedStream kann auf bestimmten Arten von Streams aufbauen. Es werden Implementierungen bereitgestellt, mit denen Bytes in einer zugrunde liegenden Datenquelle oder einem Repository gelesen und geschrieben werden. Verwenden Sie BinaryReader und BinaryWriter für das Lesen und Schreiben anderer Datentypen. BufferedStream verhindert, dass die Ein- und Ausgabe durch den Puffer verlangsamt wird, wenn dieser nicht benötigt wird. Wenn Sie stets Datenmengen lesen und schreiben, die größer als der interne Puffer sind, reserviert BufferedStream den internen Puffer möglicherweise gar nicht. BufferedStream puffert auch Lese- und Schreibvorgänge in einem gemeinsam verwendeten Puffer. Es wird davon ausgegangen, dass Sie zumeist mehrere Lese- bzw. Schreibvorgänge in Folge vornehmen und nur selten zwischen beiden wechseln.

Die folgenden Codebeispiele zeigen, wie die BufferedStream-Klasse zu der Klasse NetworkStream verwendet, um die Leistung bestimmter E/A-Vorgängen zu erhöhen. Starten Sie den Server auf einem Remotecomputer, bevor Sie den Client starten. Geben Sie den Namen des Remotecomputers beim Starten des Clients als Befehlszeilenargument an. Ändern Sie die dataArraySize-Konstante und die streamBufferSize-Konstante, um zu ermitteln, welche Auswirkungen diese Konstanten auf die Leistung haben.

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: Codieren Sie dass Wird auf dem Client


using System;
using System.IO;
using System.Globalization;
using System.Net;
using System.Net.Sockets;

public class Client
{
    const int dataArraySize    =   100;
    const int streamBufferSize =  1000;
    const int numberOfLoops    = 10000;

    static void Main(string[] args)
    {
        // Check that an argument was specified when the
        // program was invoked.
        if(args.Length == 0)
        {
            Console.WriteLine("Error: The name of the host computer" +
                " must be specified when the program is invoked.");
            return;
        }

        string remoteName = args[0];

        // Create the underlying socket and connect to the server.
        Socket clientSocket = new Socket(AddressFamily.InterNetwork,
            SocketType.Stream, ProtocolType.Tcp);

        clientSocket.Connect(new IPEndPoint(
            Dns.Resolve(remoteName).AddressList[0], 1800));

        Console.WriteLine("Client is connected.\n");

        // Create a NetworkStream that owns clientSocket and
        // then create a BufferedStream on top of the NetworkStream.
        // Both streams are disposed when execution exits the
        // using statement.
        using(Stream
            netStream = new NetworkStream(clientSocket, true),
            bufStream =
                  new BufferedStream(netStream, streamBufferSize))
        {
            // Check whether the underlying stream supports seeking.
            Console.WriteLine("NetworkStream {0} seeking.\n",
                bufStream.CanSeek ? "supports" : "does not support");

            // Send and receive data.
            if(bufStream.CanWrite)
            {
                SendData(netStream, bufStream);
            }
            if(bufStream.CanRead)
            {
                ReceiveData(netStream, bufStream);
            }

            // When bufStream is closed, netStream is in turn
            // closed, which in turn shuts down the connection
            // and closes clientSocket.
            Console.WriteLine("\nShutting down the connection.");
            bufStream.Close();
        }
    }

    static void SendData(Stream netStream, Stream bufStream)
    {
        DateTime startTime;
        double networkTime, bufferedTime;

        // Create random data to send to the server.
        byte[] dataToSend = new byte[dataArraySize];
        new Random().NextBytes(dataToSend);

        // Send the data using the NetworkStream.
        Console.WriteLine("Sending data using NetworkStream.");
        startTime = DateTime.Now;
        for(int i = 0; i < numberOfLoops; i++)
        {
            netStream.Write(dataToSend, 0, dataToSend.Length);
        }
        networkTime = (DateTime.Now - startTime).TotalSeconds;
        Console.WriteLine("{0} bytes sent in {1} seconds.\n",
            numberOfLoops * dataToSend.Length,
            networkTime.ToString("F1"));

        // Send the data using the BufferedStream.
        Console.WriteLine("Sending data using BufferedStream.");
        startTime = DateTime.Now;
        for(int i = 0; i < numberOfLoops; i++)
        {
            bufStream.Write(dataToSend, 0, dataToSend.Length);
        }
        bufStream.Flush();
        bufferedTime = (DateTime.Now - startTime).TotalSeconds;
        Console.WriteLine("{0} bytes sent in {1} seconds.\n",
            numberOfLoops * dataToSend.Length,
            bufferedTime.ToString("F1"));

        // Print the ratio of write times.
        Console.WriteLine("Sending data using the buffered " +
            "network stream was {0} {1} than using the network " +
            "stream alone.\n",
            (networkTime/bufferedTime).ToString("P0"),
            bufferedTime < networkTime ? "faster" : "slower");
    }

    static void ReceiveData(Stream netStream, Stream bufStream)
    {
        DateTime startTime;
        double networkTime, bufferedTime = 0;
        int bytesReceived = 0;
        byte[] receivedData = new byte[dataArraySize];

        // 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);
        }
        networkTime = (DateTime.Now - startTime).TotalSeconds;
        Console.WriteLine("{0} bytes received in {1} seconds.\n",
            bytesReceived.ToString(),
            networkTime.ToString("F1"));

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

        int numBytesToRead = receivedData.Length;

        while (numBytesToRead > 0)
        {
            // Read may return anything from 0 to numBytesToRead.
            int n = bufStream.Read(receivedData,0, receivedData.Length);
            // The end of the file is reached.
            if (n == 0)
                break;
            bytesReceived += n;
            numBytesToRead -= n;
        }

        bufferedTime = (DateTime.Now - startTime).TotalSeconds;
        Console.WriteLine("{0} bytes received in {1} seconds.\n",
            bytesReceived.ToString(),
            bufferedTime.ToString("F1"));

        // Print the ratio of read times.
        Console.WriteLine("Receiving data using the buffered network" +
            " stream was {0} {1} than using the network stream alone.",
            (networkTime/bufferedTime).ToString("P0"),
            bufferedTime < networkTime ? "faster" : "slower");
    }
}


Beispiel 2: Codieren Sie dass Wird auf dem Server


using System;
using System.Net;
using System.Net.Sockets;

public class Server 
{
    static void Main() 
    {
        // This is a Windows Sockets 2 error code.
        const int WSAETIMEDOUT = 10060;

        Socket serverSocket;
        int bytesReceived, totalReceived = 0;
        byte[] receivedData = new byte[2000000];

        // Create random data to send to the client.
        byte[] dataToSend = new byte[2000000];
        new Random().NextBytes(dataToSend);

        IPAddress ipAddress =
            Dns.Resolve(Dns.GetHostName()).AddressList[0];

        IPEndPoint ipEndpoint = new IPEndPoint(ipAddress, 1800);

        // Create a socket and listen for incoming connections.
        using(Socket listenSocket = new Socket(
            AddressFamily.InterNetwork, SocketType.Stream, 
            ProtocolType.Tcp))
        {
            listenSocket.Bind(ipEndpoint);
            listenSocket.Listen(1);

            // Accept a connection and create a socket to handle it.
            serverSocket = listenSocket.Accept();
            Console.WriteLine("Server is connected.\n");
        }

        try
        {
            // Send data to the client.
            Console.Write("Sending data ... ");
            int bytesSent = serverSocket.Send(
                dataToSend, 0, dataToSend.Length, SocketFlags.None);
            Console.WriteLine("{0} bytes sent.\n", 
                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;
                }
                while(bytesReceived != 0);
            }
            catch(SocketException e)
            {
                if(e.ErrorCode == WSAETIMEDOUT)
                {
                    // Data was not received within the given time.
                    // Assume that the transmission has ended.
                }
                else
                {
                    Console.WriteLine("{0}: {1}\n", 
                        e.GetType().Name, e.Message);
                }
            }
            finally
            {
                Console.WriteLine("{0} bytes received.\n",
                    totalReceived.ToString());
            }
        }
        finally
        {
            serverSocket.Shutdown(SocketShutdown.Both);
            Console.WriteLine("Connection shut down.");
            serverSocket.Close();
        }
    }
}


.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Alle öffentlichen static (Shared in Visual Basic)-Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft