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 ref class BufferedStream sealed : 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(array<Byte>^, Int32, Int32, AsyncCallback^, Object^)

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

System_CAPS_pubmethodBeginWrite(array<Byte>^, Int32, Int32, AsyncCallback^, Object^)

Beginnt einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync. Weitere Informationen finden Sie im Abschnitt "Hinweise".)(Überschreibt Stream::BeginWrite(array<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 verwendet die enthält.(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 das Dienstobjekt für aktuellen Lebensdauer, das steuert, die lebensdauerrichtlinie für diese Instanz ab.(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 Lebensdauerrichtlinie für diese Instanz ab.(Geerbt von „MarshalByRefObject“.)

System_CAPS_pubmethodRead(array<Byte>^, Int32, Int32)

Kopiert Bytes aus dem aktuellen gepufferten Stream in ein Array.(Überschreibt Stream::Read(array<Byte>^, Int32, Int32).)

System_CAPS_pubmethodReadAsync(array<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(array<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(array<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(array<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(array<Byte>^, Int32, Int32).)

System_CAPS_pubmethodWriteAsync(array<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(array<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(array<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 den Typ nicht mehr verwenden, sollten Sie ihn entweder direkt oder indirekt freigeben. Um den Typ direkt freizugeben, rufen Sie seine Dispose-Methode in einem try/catch Block auf. Um es indirekt freizugeben, verwenden Sie ein Sprachkonstrukt wie z. B. using (in c#) oder Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt "Verwenden eines Objekts, welches IDisposable implementiert" im IDisposable Themenabschnitt 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.dll>

using namespace System;
using namespace System::IO;
using namespace System::Globalization;
using namespace System::Net;
using namespace System::Net::Sockets;
static const int streamBufferSize = 1000;
public ref class Client
{
private:
   literal int dataArraySize = 100;
   literal int numberOfLoops = 10000;
   Client(){}


public:
   static void ReceiveData( Stream^ netStream, Stream^ bufStream )
   {
      DateTime startTime;
      Double networkTime;
      Double bufferedTime = 0;
      int bytesReceived = 0;
      array<Byte>^receivedData = gcnew array<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;
      while ( bytesReceived < numberOfLoops * receivedData->Length )
      {
         bytesReceived += bufStream->Read( receivedData, 0, receivedData->Length );
      }

      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 ? (String^)"faster" : "slower" );
   }

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

      // Create random data to send to the server.
      array<Byte>^dataToSend = gcnew array<Byte>(dataArraySize);
      (gcnew 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).ToString(), 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).ToString(), 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 ? (String^)"faster" : "slower" );
   }

};

int main( int argc, char *argv[] )
{

   // Check that an argument was specified when the 
   // program was invoked.
   if ( argc == 1 )
   {
      Console::WriteLine( "Error: The name of the host computer"
      " must be specified when the program is invoked." );
      return  -1;
   }

   String^ remoteName = gcnew String( argv[ 1 ] );

   // Create the underlying socket and connect to the server.
   Socket^ clientSocket = gcnew Socket( AddressFamily::InterNetwork,SocketType::Stream,ProtocolType::Tcp );
   clientSocket->Connect( gcnew 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.
   NetworkStream^ netStream = gcnew NetworkStream( clientSocket,true );
   BufferedStream^ bufStream = gcnew BufferedStream( netStream,streamBufferSize );

   try
   {

      // Check whether the underlying stream supports seeking.
      Console::WriteLine( "NetworkStream {0} seeking.\n", bufStream->CanSeek ? (String^)"supports" : "does not support" );

      // Send and receive data.
      if ( bufStream->CanWrite )
      {
         Client::SendData( netStream, bufStream );
      }

      if ( bufStream->CanRead )
      {
         Client::ReceiveData( netStream, bufStream );
      }

   }
   finally
   {

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

   }

}

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

#using <system.dll>

using namespace System;
using namespace System::Net;
using namespace System::Net::Sockets;
int main()
{

   // This is a Windows Sockets 2 error code.
   const int WSAETIMEDOUT = 10060;
   Socket^ serverSocket;
   int bytesReceived;
   int totalReceived = 0;
   array<Byte>^receivedData = gcnew array<Byte>(2000000);

   // Create random data to send to the client.
   array<Byte>^dataToSend = gcnew array<Byte>(2000000);
   (gcnew Random)->NextBytes( dataToSend );
   IPAddress^ ipAddress = Dns::Resolve( Dns::GetHostName() )->AddressList[ 0 ];
   IPEndPoint^ ipEndpoint = gcnew IPEndPoint( ipAddress,1800 );

   // Create a socket and listen for incoming connections.
   Socket^ listenSocket = gcnew 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.\n" );
   }
   finally
   {
      listenSocket->Close();
   }

   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: