BufferedStream Klasse
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Fügt eine Pufferebene zu Lese- und Schreibvorgängen auf einem anderen Stream hinzu. Diese Klasse kann nicht vererbt werden.
public ref class BufferedStream sealed : System::IO::Streampublic sealed class BufferedStream : System.IO.Stream[System.Runtime.InteropServices.ComVisible(true)]
public sealed class BufferedStream : System.IO.Streamtype BufferedStream = class
inherit Stream[<System.Runtime.InteropServices.ComVisible(true)>]
type BufferedStream = class
inherit StreamPublic NotInheritable Class BufferedStream
Inherits Stream- Vererbung
- Vererbung
- Attribute
Beispiele
Die folgenden Codebeispiele zeigen, wie Sie die BufferedStream Klasse über die NetworkStream Klasse verwenden, um die Leistung bestimmter I/O-Vorgänge zu erhöhen. Starten Sie den Server auf einem Remotecomputer, bevor Sie den Client starten. Geben Sie den Namen des Remotecomputers als Befehlszeilenargument an, wenn der Client gestartet wird. Variieren Sie die 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();
}
}
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");
}
}
module Client
open System
open System.IO
open System.Net
open System.Net.Sockets
let dataArraySize = 100
let streamBufferSize = 1000
let numberOfLoops = 10000
let sendData (netStream: Stream) (bufStream: Stream) =
// Create random data to send to the server.
let dataToSend = Array.zeroCreate dataArraySize
Random().NextBytes dataToSend
// Send the data using the NetworkStream.
printfn "Sending data using NetworkStream."
let startTime = DateTime.Now
for _ = 0 to numberOfLoops - 1 do
netStream.Write(dataToSend, 0, dataToSend.Length)
let networkTime = (DateTime.Now - startTime).TotalSeconds
printfn $"{numberOfLoops * dataToSend.Length} bytes sent in {networkTime:F1} seconds.\n"
// Send the data using the BufferedStream.
printfn "Sending data using BufferedStream."
let startTime = DateTime.Now
for _ = 0 to numberOfLoops - 1 do
bufStream.Write(dataToSend, 0, dataToSend.Length)
bufStream.Flush()
let bufferedTime = (DateTime.Now - startTime).TotalSeconds
printfn $"{numberOfLoops * dataToSend.Length} bytes sent in {bufferedTime:F1} seconds.\n"
// Print the ratio of write times.
printfn $"""Sending data using the buffered network stream was {networkTime / bufferedTime:P0} {if bufferedTime < networkTime then "faster" else "slower"} than using the network stream alone."""
printfn ""
let receiveData (netStream: Stream) (bufStream: Stream) =
let mutable bytesReceived = 0
let receivedData = Array.zeroCreate dataArraySize
// Receive data using the NetworkStream.
printfn "Receiving data using NetworkStream."
let startTime = DateTime.Now
while bytesReceived < numberOfLoops * receivedData.Length do
bytesReceived <- bytesReceived + netStream.Read(receivedData, 0, receivedData.Length)
let networkTime = (DateTime.Now - startTime).TotalSeconds
printfn $"{bytesReceived} bytes received in {networkTime:F1} seconds.\n"
// Receive data using the BufferedStream.
printfn "Receiving data using BufferedStream."
bytesReceived <- 0
let startTime = DateTime.Now
let mutable numBytesToRead = receivedData.Length
let mutable broken = false
while not broken && numBytesToRead > 0 do
// Read may return anything from 0 to numBytesToRead.
let n = bufStream.Read(receivedData,0, receivedData.Length)
// The end of the file is reached.
if n = 0 then
broken <- true
else
bytesReceived <- bytesReceived + n
numBytesToRead <- numBytesToRead - n
let bufferedTime = (DateTime.Now - startTime).TotalSeconds
printfn $"{bytesReceived} bytes received in {bufferedTime:F1} seconds.\n"
// Print the ratio of read times.
printfn $"""Receiving data using the buffered network stream was {networkTime / bufferedTime:P0} {if bufferedTime < networkTime then "faster" else "slower"} than using the network stream alone."""
[<EntryPoint>]
let main args =
// Check that an argument was specified when the
// program was invoked.
if args.Length = 0 then
printfn "Error: The name of the host computer must be specified when the program is invoked."
else
let remoteName = args[0]
// Create the underlying socket and connect to the server.
let clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
clientSocket.Connect(IPEndPoint(Dns.GetHostEntry(remoteName).AddressList[0], 1800))
printfn "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.
use netStream = new NetworkStream(clientSocket, true)
use bufStream = new BufferedStream(netStream, streamBufferSize)
// Check whether the underlying stream supports seeking.
printfn $"""NetworkStream {if bufStream.CanSeek then "supports" else "does not support"} seeking.\n"""
// Send and receive data.
if bufStream.CanWrite then
sendData netStream bufStream
if bufStream.CanRead then
receiveData netStream bufStream
// When bufStream is closed, netStream is in turn
// closed, which in turn shuts down the connection
// and closes clientSocket.
printfn "\nShutting down the connection."
bufStream.Close()
0
' Compile using /r:System.dll.
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
#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();
}
}
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();
}
}
}
module Server
open System
open System.Net
open System.Net.Sockets
// This is a Windows Sockets 2 error code.
let WSAETIMEDOUT = 10060
let mutable bytesReceived = -1
let mutable totalReceived = 0
let receivedData = Array.zeroCreate 2000000
// Create random data to send to the client.
let dataToSend = Array.zeroCreate 2000000
Random().NextBytes dataToSend
let ipAddress = Dns.GetHostEntry(Dns.GetHostName()).AddressList[0]
let ipEndpoint = IPEndPoint(ipAddress, 1800)
// Create a socket and listen for incoming connections.
let serverSocket =
use 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.
listenSocket.Accept()
printfn "Server is connected.\n"
try
// Send data to the client.
printf "Sending data ... "
let bytesSent = serverSocket.Send(dataToSend, 0, dataToSend.Length, SocketFlags.None)
printfn $"{bytesSent} bytes sent.\n"
// Set the timeout for receiving data to 2 seconds.
serverSocket.SetSocketOption(SocketOptionLevel.Socket,
SocketOptionName.ReceiveTimeout, 2000)
// Receive data from the client.
printf "Receiving data ... "
try
try
while bytesReceived <> 0 do
bytesReceived <- serverSocket.Receive(receivedData, 0, receivedData.Length, SocketFlags.None)
totalReceived <- totalReceived + bytesReceived
with :? SocketException as e ->
if e.ErrorCode = WSAETIMEDOUT then
// Data was not received within the given time.
// Assume that the transmission has ended.
()
else
printfn $"{e.GetType().Name}: {e.Message}\n"
finally
printfn $"{totalReceived} bytes received.\n"
finally
serverSocket.Shutdown SocketShutdown.Both
printfn "Connection shut down."
serverSocket.Close()
' Compile using /r:System.dll.
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
Hinweise
Ein Puffer ist ein Block von Bytes im Arbeitsspeicher, der zum Zwischenspeichern von Daten verwendet wird, wodurch die Anzahl der Aufrufe an das Betriebssystem reduziert wird. Puffer verbessern die Lese- und Schreibleistung. Ein Puffer kann entweder zum Lesen oder Schreiben verwendet werden, aber nie gleichzeitig. Die Read Und Write Methoden des automatischen Verwaltens des BufferedStream Puffers.
Wichtig
Dieser Typ implementiert die IDisposable-Schnittstelle. Nach Abschluss der Verwendung sollten Sie den Typ entweder direkt oder indirekt löschen. Zum direkten Löschen des Typs rufen Sie seine Dispose-Methode in einem try/catch-Block auf. Zum indirekten Löschen verwenden Sie ein Sprachkonstrukt wie using (in C#) oder Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt „Verwenden eines Objekts, das IDisposable implementiert“ des Themas „Die IDisposable-Schnittstelle“.
BufferedStream kann um bestimmte Arten von Datenströmen zusammengesetzt werden. Es stellt Implementierungen zum Lesen und Schreiben von Bytes in eine zugrunde liegende Datenquelle oder ein Repository bereit. Verwenden und BinaryWriter schreiben Sie BinaryReader andere Datentypen. BufferedStream ist so konzipiert, dass der Puffer die Eingabe und Ausgabe verlangsamt, wenn der Puffer nicht benötigt wird. Wenn Sie immer größen größer als die interne Puffergröße lesen und schreiben, BufferedStream weisen Sie den internen Puffer möglicherweise nicht einmal zu. BufferedStream puffert auch Lese- und Schreibvorgänge in einem freigegebenen Puffer. Es wird davon ausgegangen, dass Sie fast immer eine Reihe von Lese- oder Schreibvorgängen ausführen, aber selten zwischen den beiden wechseln.
Konstruktoren
| BufferedStream(Stream) |
Initialisiert eine neue Instanz der BufferedStream-Klasse mit einer Standardpuffergröße von 4096 Bytes. |
| BufferedStream(Stream, Int32) |
Initialisiert eine neue Instanz der BufferedStream-Klasse mit der angegebenen Puffergröße. |
Eigenschaften
| BufferSize |
Ruft die Puffergröße in Bytes für diesen gepufferten Stream ab. |
| CanRead |
Ruft einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. |
| CanSeek |
Ruft einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. |
| CanTimeout |
Ruft einen Wert ab, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. (Geerbt von Stream) |
| CanWrite |
Ruft einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. |
| Length |
Ruft die Länge des Streams in Bytes ab. |
| Position |
Ruft die Position im aktuellen Stream ab. |
| ReadTimeout |
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) |
| UnderlyingStream |
Ruft die zugrunde liegende Stream-Instanz für diesen gepufferten Stream ab. |
| WriteTimeout |
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) |
Methoden
| BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) |
Beginnt einen asynchronen Lesevorgang. (Verwenden Sie stattdessen ReadAsync(Byte[], Int32, Int32, CancellationToken).) |
| BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) |
Beginnt einen asynchronen Lesevorgang. (Verwenden Sie stattdessen ReadAsync(Byte[], Int32, Int32).) (Geerbt von Stream) |
| BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) |
Beginnt einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync(Byte[], Int32, Int32, CancellationToken).) |
| BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) |
Beginnt einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync(Byte[], Int32, Int32).) (Geerbt von Stream) |
| Close() |
Schließt den Stream und gibt alle Ressourcen frei (insbesondere Systemressourcen wie Sockets und Dateihandles), die dem aktuellen Pufferstream zugeordnet sind. |
| Close() |
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) |
| CopyTo(Stream) |
Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. (Geerbt von Stream) |
| CopyTo(Stream, Int32) |
Liest alle Bytes aus dem aktuellen gepufferten Stream und schreibt sie in einen anderen Datenstrom. |
| CopyTo(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) |
| CopyToAsync(Stream) |
Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. (Geerbt von Stream) |
| CopyToAsync(Stream, CancellationToken) |
Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung eines angegebenen Abbruchtokens in einen anderen Stream. (Geerbt von Stream) |
| CopyToAsync(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) |
| CopyToAsync(Stream, Int32, CancellationToken) |
Liest die Bytes asynchron aus dem aktuellen gepufferten Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. |
| CopyToAsync(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) |
| CreateObjRef(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) |
| CreateWaitHandle() |
Veraltet.
Veraltet.
Reserviert ein WaitHandle-Objekt. (Geerbt von Stream) |
| Dispose() |
Gibt alle vom Stream verwendeten Ressourcen frei. (Geerbt von Stream) |
| Dispose(Boolean) |
Gibt die von Stream verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. (Geerbt von Stream) |
| DisposeAsync() |
Gibt die nicht verwalteten Ressourcen, die vom gepufferten Stream verwendet werden, asynchron frei. |
| DisposeAsync() |
Gibt die nicht verwalteten Ressourcen, die von der Stream verwendet werden, asynchron frei. (Geerbt von Stream) |
| EndRead(IAsyncResult) |
Wartet, bis der ausstehende asynchrone Lesevorgang abgeschlossen ist. (Verwenden Sie stattdessen ReadAsync(Byte[], Int32, Int32, CancellationToken).) |
| EndRead(IAsyncResult) |
Wartet, bis der ausstehende asynchrone Lesevorgang abgeschlossen ist. (Verwenden Sie stattdessen ReadAsync(Byte[], Int32, Int32).) (Geerbt von Stream) |
| EndWrite(IAsyncResult) |
Beendet einen asynchronen Schreibvorgang und blockiert, bis die E/A-Operation abgeschlossen wurde. (Verwenden Sie stattdessen WriteAsync(Byte[], Int32, Int32, CancellationToken).) |
| EndWrite(IAsyncResult) |
Beendet einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync(Byte[], Int32, Int32).) (Geerbt von Stream) |
| Equals(Object) |
Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object) |
| Flush() |
Löscht sämtliche Puffer für diesen Stream und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. |
| FlushAsync() |
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) |
| FlushAsync(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. |
| FlushAsync(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. (Geerbt von Stream) |
| GetHashCode() |
Fungiert als Standardhashfunktion. (Geerbt von Object) |
| GetLifetimeService() |
Veraltet.
Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject) |
| GetType() |
Ruft den Type der aktuellen Instanz ab. (Geerbt von Object) |
| InitializeLifetimeService() |
Veraltet.
Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject) |
| MemberwiseClone() |
Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object) |
| MemberwiseClone(Boolean) |
Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject) |
| ObjectInvariant() |
Veraltet.
Bietet Unterstützung für einen Contract. (Geerbt von Stream) |
| Read(Byte[], Int32, Int32) |
Kopiert Bytes aus dem aktuellen gepufferten Stream in ein Array. |
| Read(Span<Byte>) |
Kopiert Bytes aus dem gepufferten Stream in eine Bytespanne und verschiebt die Position im gepufferten Stream um die Anzahl der gelesenen Bytes. |
| Read(Span<Byte>) |
Liest beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes aus dem aktuellen Stream und erhöht die Position im Stream um die Anzahl der gelesenen Bytes. (Geerbt von Stream) |
| ReadAsync(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) |
| ReadAsync(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. |
| ReadAsync(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. (Geerbt von Stream) |
| ReadAsync(Memory<Byte>, CancellationToken) |
Liest eine Bytesequenz asynchron aus dem aktuellen gepufferten Stream und setzt die Position in diesem gepufferten Stream um die Anzahl der gelesenen Bytes nach vorn. |
| ReadAsync(Memory<Byte>, 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. (Geerbt von Stream) |
| ReadByte() |
Liest ein Byte aus dem zugrunde liegenden Stream und gibt dieses in ein |
| Seek(Int64, SeekOrigin) |
Legt die Position im aktuellen gepufferten Stream fest. |
| SetLength(Int64) |
Legt die Länge des gepufferten Streams fest. |
| ToString() |
Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object) |
| Write(Byte[], Int32, Int32) |
Kopiert Bytes in den gepufferten Stream und verschiebt die aktuelle Position im gepufferten Stream um die Anzahl der geschriebenen Bytes. |
| Write(ReadOnlySpan<Byte>) |
Schreibt eine Bytesequenz in den aktuellen gepufferten Stream und setzt die aktuelle Position in diesem gepufferten Stream um die Anzahl der geschriebenen Bytes nach vorn. |
| Write(ReadOnlySpan<Byte>) |
Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes. (Geerbt von Stream) |
| WriteAsync(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) |
| WriteAsync(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. |
| WriteAsync(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. (Geerbt von Stream) |
| WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) |
Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen gepufferten Stream und erhöht die aktuelle Position im gepufferten Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. |
| WriteAsync(ReadOnlyMemory<Byte>, 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. (Geerbt von Stream) |
| WriteByte(Byte) |
Schreibt ein Byte an die aktuelle Position im gepufferten Stream. |
Explizite Schnittstellenimplementierungen
| IDisposable.Dispose() |
Gibt alle vom Stream verwendeten Ressourcen frei. (Geerbt von Stream) |
Erweiterungsmethoden
| ConfigureAwait(IAsyncDisposable, Boolean) |
Konfiguriert, wie Wartezeiten auf die Aufgaben angewandt werden, die von einem asynchronen verwerfbaren Element zurückgegeben werden. |