BufferedStream Klasse
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 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)

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

[ComVisibleAttribute(true)]
public sealed class BufferedStream : 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.(Setzt "Stream.CanRead" außer Kraft.)

System_CAPS_pubpropertyCanSeek

Ruft einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt.(Setzt "Stream.CanSeek" außer Kraft.)

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.(Setzt "Stream.CanWrite" außer Kraft.)

System_CAPS_pubpropertyLength

Ruft die Länge des Streams in Bytes ab.(Setzt "Stream.Length" außer Kraft.)

System_CAPS_pubpropertyPosition

Ruft die Position im aktuellen Stream ab.(Setzt "Stream.Position" außer Kraft.)

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".)(Setzt "Stream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)" außer Kraft.)

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

Beginnt einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync. Weitere Informationen finden Sie im Abschnitt "Hinweise".)(Setzt "Stream.BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)" außer Kraft.)

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 mit allen 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".)(Setzt "Stream.EndRead(IAsyncResult)" außer Kraft.)

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".)(Setzt "Stream.EndWrite(IAsyncResult)" außer Kraft.)

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 veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät.(Setzt "Stream.Flush()" außer Kraft.)

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 und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen.(Setzt "Stream.FlushAsync(CancellationToken)" außer Kraft.)

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 ab, mit dem die Lebensdauerrichtlinien für diese Instanz gesteuert werden können.(Geerbt von MarshalByRefObject.)

System_CAPS_pubmethodRead(Byte[], Int32, Int32)

Kopiert Bytes aus dem aktuellen gepufferten Stream in ein Array.(Setzt "Stream.Read(Byte[], Int32, Int32)" außer Kraft.)

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 aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen.(Setzt "Stream.ReadAsync(Byte[], Int32, Int32, CancellationToken)" außer Kraft.)

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.(Setzt "Stream.ReadByte()" außer Kraft.)

System_CAPS_pubmethodSeek(Int64, SeekOrigin)

Legt die Position im aktuellen gepufferten Stream fest.(Setzt "Stream.Seek(Int64, SeekOrigin)" außer Kraft.)

System_CAPS_pubmethodSetLength(Int64)

Legt die Länge des gepufferten Streams fest.(Setzt "Stream.SetLength(Int64)" außer Kraft.)

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 verschiebt die aktuelle Position im gepufferten Stream um die Anzahl der geschriebenen Bytes.(Setzt "Stream.Write(Byte[], Int32, Int32)" außer Kraft.)

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.(Setzt "Stream.WriteAsync(Byte[], Int32, Int32, CancellationToken)" außer Kraft.)

System_CAPS_pubmethodWriteByte(Byte)

Schreibt ein Byte an die aktuelle Position im gepufferten Stream.(Setzt "Stream.WriteByte(Byte)" außer Kraft.)

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.  

System_CAPS_importantWichtig

Dieser Typ implementiert die IDisposable-Schnittstelle.   Nach der Verwendung dieses Typs, sollten Sie diesen direkt oder indirekt wieder freigeben.   Um den Typ direkt zu löschen, rufen Sie die Dispose-Methode in einem try/catch-Block auf.   Um den Typ 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();
        }
    }
}

Universal Windows Platform
Verfügbar seit 10
.NET Framework
Verfügbar seit 1.1

Öffentliche statische (in Visual Basic freigegebene) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Zurück zum Anfang
Anzeigen:
© 2016 Microsoft