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

 

Veröffentlicht: Oktober 2016

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 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.(Ü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.

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: Code, der auf dem Server ausgeführt wird.

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
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: