BufferedStream Class
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Adds a buffering layer to read and write operations on another stream. This class cannot be inherited.
public ref class BufferedStream sealed : System::IO::Stream
public sealed class BufferedStream : System.IO.Stream
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class BufferedStream : System.IO.Stream
type BufferedStream = class
inherit Stream
[<System.Runtime.InteropServices.ComVisible(true)>]
type BufferedStream = class
inherit Stream
Public NotInheritable Class BufferedStream
Inherits Stream
- Inheritance
- Inheritance
- Attributes
Examples
The following code examples show how to use the BufferedStream
class over the NetworkStream
class to increase the performance of certain I/O operations. Start the server on a remote computer before starting the client. Specify the remote computer name as a command-line argument when starting the client. Vary the dataArraySize
and streamBufferSize
constants to view their effect on performance.
The first example shows the code that runs on the client, and the second example shows the code that runs on the server.
Example 1: Code that runs on the client
#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
Example 2: Code that runs on the server
#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
Remarks
A buffer is a block of bytes in memory used to cache data, thereby reducing the number of calls to the operating system. Buffers improve read and write performance. A buffer can be used for either reading or writing, but never both simultaneously. The Read and Write methods of BufferedStream
automatically maintain the buffer.
Important
This type implements the IDisposable interface. When you have finished using the type, you should dispose of it either directly or indirectly. To dispose of the type directly, call its Dispose method in a try
/catch
block. To dispose of it indirectly, use a language construct such as using
(in C#) or Using
(in Visual Basic). For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.
BufferedStream
can be composed around certain types of streams. It provides implementations for reading and writing bytes to an underlying data source or repository. Use BinaryReader and BinaryWriter for reading and writing other data types. BufferedStream
is designed to prevent the buffer from slowing down input and output when the buffer is not needed. If you always read and write for sizes greater than the internal buffer size, then BufferedStream
might not even allocate the internal buffer. BufferedStream
also buffers reads and writes in a shared buffer. It is assumed that you will almost always be doing a series of reads or writes, but rarely alternate between the two of them.
Constructors
BufferedStream(Stream) |
Initializes a new instance of the BufferedStream class with a default buffer size of 4096 bytes. |
BufferedStream(Stream, Int32) |
Initializes a new instance of the BufferedStream class with the specified buffer size. |
Properties
BufferSize |
Gets the buffer size in bytes for this buffered stream. |
CanRead |
Gets a value indicating whether the current stream supports reading. |
CanSeek |
Gets a value indicating whether the current stream supports seeking. |
CanTimeout |
Gets a value that determines whether the current stream can time out. (Inherited from Stream) |
CanWrite |
Gets a value indicating whether the current stream supports writing. |
Length |
Gets the stream length in bytes. |
Position |
Gets the position within the current stream. |
ReadTimeout |
Gets or sets a value, in milliseconds, that determines how long the stream will attempt to read before timing out. (Inherited from Stream) |
UnderlyingStream |
Gets the underlying Stream instance for this buffered stream. |
WriteTimeout |
Gets or sets a value, in milliseconds, that determines how long the stream will attempt to write before timing out. (Inherited from Stream) |
Methods
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) |
Begins an asynchronous read operation. (Consider using ReadAsync(Byte[], Int32, Int32, CancellationToken) instead.) |
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) |
Begins an asynchronous read operation. (Consider using ReadAsync(Byte[], Int32, Int32) instead.) (Inherited from Stream) |
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) |
Begins an asynchronous write operation. (Consider using WriteAsync(Byte[], Int32, Int32, CancellationToken) instead.) |
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) |
Begins an asynchronous write operation. (Consider using WriteAsync(Byte[], Int32, Int32) instead.) (Inherited from Stream) |
Close() |
Closes the stream and releases any resources (especially system resources such as sockets and file handles) associated with the current buffered stream. |
Close() |
Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Instead of calling this method, ensure that the stream is properly disposed. (Inherited from Stream) |
CopyTo(Stream) |
Reads the bytes from the current stream and writes them to another stream. Both streams positions are advanced by the number of bytes copied. (Inherited from Stream) |
CopyTo(Stream, Int32) |
Reads the bytes from the current buffered stream and writes them to another stream. |
CopyTo(Stream, Int32) |
Reads the bytes from the current stream and writes them to another stream, using a specified buffer size. Both streams positions are advanced by the number of bytes copied. (Inherited from Stream) |
CopyToAsync(Stream) |
Asynchronously reads the bytes from the current stream and writes them to another stream. Both streams positions are advanced by the number of bytes copied. (Inherited from Stream) |
CopyToAsync(Stream, CancellationToken) |
Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token. Both streams positions are advanced by the number of bytes copied. (Inherited from Stream) |
CopyToAsync(Stream, Int32) |
Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size. Both streams positions are advanced by the number of bytes copied. (Inherited from Stream) |
CopyToAsync(Stream, Int32, CancellationToken) |
Asynchronously reads the bytes from the current buffered stream and writes them to another stream, using a specified buffer size and cancellation token. |
CopyToAsync(Stream, Int32, CancellationToken) |
Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. Both streams positions are advanced by the number of bytes copied. (Inherited from Stream) |
CreateObjRef(Type) |
Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object. (Inherited from MarshalByRefObject) |
CreateWaitHandle() |
Obsolete.
Obsolete.
Obsolete.
Allocates a WaitHandle object. (Inherited from Stream) |
Dispose() |
Releases all resources used by the Stream. (Inherited from Stream) |
Dispose(Boolean) |
Releases the unmanaged resources used by the Stream and optionally releases the managed resources. (Inherited from Stream) |
DisposeAsync() |
Asynchronously releases the unmanaged resources used by the buffered stream. |
DisposeAsync() |
Asynchronously releases the unmanaged resources used by the Stream. (Inherited from Stream) |
EndRead(IAsyncResult) |
Waits for the pending asynchronous read operation to complete. (Consider using ReadAsync(Byte[], Int32, Int32, CancellationToken) instead.) |
EndRead(IAsyncResult) |
Waits for the pending asynchronous read to complete. (Consider using ReadAsync(Byte[], Int32, Int32) instead.) (Inherited from Stream) |
EndWrite(IAsyncResult) |
Ends an asynchronous write operation and blocks until the I/O operation is complete. (Consider using WriteAsync(Byte[], Int32, Int32, CancellationToken) instead.) |
EndWrite(IAsyncResult) |
Ends an asynchronous write operation. (Consider using WriteAsync(Byte[], Int32, Int32) instead.) (Inherited from Stream) |
Equals(Object) |
Determines whether the specified object is equal to the current object. (Inherited from Object) |
Flush() |
Clears all buffers for this stream and causes any buffered data to be written to the underlying device. |
FlushAsync() |
Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device. (Inherited from Stream) |
FlushAsync(CancellationToken) |
Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests. |
FlushAsync(CancellationToken) |
Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests. (Inherited from Stream) |
GetHashCode() |
Serves as the default hash function. (Inherited from Object) |
GetLifetimeService() |
Obsolete.
Retrieves the current lifetime service object that controls the lifetime policy for this instance. (Inherited from MarshalByRefObject) |
GetType() |
Gets the Type of the current instance. (Inherited from Object) |
InitializeLifetimeService() |
Obsolete.
Obtains a lifetime service object to control the lifetime policy for this instance. (Inherited from MarshalByRefObject) |
MemberwiseClone() |
Creates a shallow copy of the current Object. (Inherited from Object) |
MemberwiseClone(Boolean) |
Creates a shallow copy of the current MarshalByRefObject object. (Inherited from MarshalByRefObject) |
ObjectInvariant() |
Obsolete.
Provides support for a Contract. (Inherited from Stream) |
Read(Byte[], Int32, Int32) |
Copies bytes from the current buffered stream to an array. |
Read(Span<Byte>) |
Copies bytes from the current buffered stream to a byte span and advances the position within the buffered stream by the number of bytes read. |
Read(Span<Byte>) |
When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. (Inherited from Stream) |
ReadAsync(Byte[], Int32, Int32) |
Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. (Inherited from Stream) |
ReadAsync(Byte[], Int32, Int32, CancellationToken) |
Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. |
ReadAsync(Byte[], Int32, Int32, CancellationToken) |
Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. (Inherited from Stream) |
ReadAsync(Memory<Byte>, CancellationToken) |
Asynchronously reads a sequence of bytes from the current buffered stream and advances the position within the buffered stream by the number of bytes read. |
ReadAsync(Memory<Byte>, CancellationToken) |
Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. (Inherited from Stream) |
ReadAtLeast(Span<Byte>, Int32, Boolean) |
Reads at least a minimum number of bytes from the current stream and advances the position within the stream by the number of bytes read. (Inherited from Stream) |
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken) |
Asynchronously reads at least a minimum number of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. (Inherited from Stream) |
ReadByte() |
Reads a byte from the underlying stream and returns the byte cast to an |
ReadExactly(Byte[], Int32, Int32) |
Reads |
ReadExactly(Span<Byte>) |
Reads bytes from the current stream and advances the position within the stream until the |
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken) |
Asynchronously reads |
ReadExactlyAsync(Memory<Byte>, CancellationToken) |
Asynchronously reads bytes from the current stream, advances the position within the stream until the |
Seek(Int64, SeekOrigin) |
Sets the position within the current buffered stream. |
SetLength(Int64) |
Sets the length of the buffered stream. |
ToString() |
Returns a string that represents the current object. (Inherited from Object) |
Write(Byte[], Int32, Int32) |
Copies bytes to the buffered stream and advances the current position within the buffered stream by the number of bytes written. |
Write(ReadOnlySpan<Byte>) |
Writes a sequence of bytes to the current buffered stream and advances the current position within this buffered stream by the number of bytes written. |
Write(ReadOnlySpan<Byte>) |
When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. (Inherited from Stream) |
WriteAsync(Byte[], Int32, Int32) |
Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. (Inherited from Stream) |
WriteAsync(Byte[], Int32, Int32, CancellationToken) |
Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. |
WriteAsync(Byte[], Int32, Int32, CancellationToken) |
Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. (Inherited from Stream) |
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) |
Asynchronously writes a sequence of bytes to the current buffered stream, advances the current position within this buffered stream by the number of bytes written, and monitors cancellation requests. |
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) |
Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. (Inherited from Stream) |
WriteByte(Byte) |
Writes a byte to the current position in the buffered stream. |
Explicit Interface Implementations
IDisposable.Dispose() |
Releases all resources used by the Stream. (Inherited from Stream) |
Extension Methods
CopyToAsync(Stream, PipeWriter, CancellationToken) |
Asynchronously reads the bytes from the Stream and writes them to the specified PipeWriter, using a cancellation token. |
ConfigureAwait(IAsyncDisposable, Boolean) |
Configures how awaits on the tasks returned from an async disposable will be performed. |