Bagikan melalui


BufferedStream Kelas

Definisi

Menambahkan lapisan buffering untuk membaca dan menulis operasi pada aliran lain. Kelas ini tidak dapat diwariskan.

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
Warisan
BufferedStream
Warisan
Atribut

Contoh

Contoh kode berikut menunjukkan cara menggunakan kelas BufferedStream di atas kelas NetworkStream untuk meningkatkan performa operasi I/O tertentu. Mulai server pada komputer jarak jauh sebelum memulai klien. Tentukan nama komputer jarak jauh sebagai argumen baris perintah saat memulai klien. Bervariasi konstanta dataArraySize dan streamBufferSize untuk melihat efeknya pada performa.

Contoh pertama menunjukkan kode yang berjalan pada klien, dan contoh kedua menunjukkan kode yang berjalan di server.

Contoh 1: Kode yang berjalan pada klien

#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

Contoh 2: Kode yang berjalan di 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

Keterangan

Buffer adalah blok byte dalam memori yang digunakan untuk menyimpan data, sehingga mengurangi jumlah panggilan ke sistem operasi. Buffer meningkatkan performa baca dan tulis. Buffer dapat digunakan untuk membaca atau menulis, tetapi tidak pernah keduanya secara bersamaan. Metode Read dan WriteBufferedStream secara otomatis mempertahankan buffer.

Penting

Jenis ini mengimplementasikan antarmuka IDisposable. Setelah selesai menggunakan jenisnya, Anda harus membuangnya baik secara langsung maupun tidak langsung. Untuk membuang jenis secara langsung, panggil metode Dispose dalam blok try/catch. Untuk membuangnya secara tidak langsung, gunakan konstruksi bahasa seperti using (dalam C#) atau Using (di Visual Basic). Untuk informasi selengkapnya, lihat bagian "Menggunakan Objek yang Menerapkan IDisposable" di topik antarmuka IDisposable.

BufferedStream dapat terdiri dari jenis aliran tertentu. Ini menyediakan implementasi untuk membaca dan menulis byte ke sumber data atau repositori yang mendasar. Gunakan BinaryReader dan BinaryWriter untuk membaca dan menulis jenis data lainnya. BufferedStream dirancang untuk mencegah buffer memperlambat input dan output saat buffer tidak diperlukan. Jika Anda selalu membaca dan menulis untuk ukuran yang lebih besar dari ukuran buffer internal, maka BufferedStream mungkin bahkan tidak mengalokasikan buffer internal. BufferedStream juga buffer membaca dan menulis dalam buffer bersama. Diasumsikan bahwa Anda hampir selalu akan melakukan serangkaian bacaan atau tulisan, tetapi jarang bergantian di antara keduanya.

Konstruktor

BufferedStream(Stream)

Menginisialisasi instans baru kelas BufferedStream dengan ukuran buffer default 4096 byte.

BufferedStream(Stream, Int32)

Menginisialisasi instans baru kelas BufferedStream dengan ukuran buffer yang ditentukan.

Properti

BufferSize

Mendapatkan ukuran buffer dalam byte untuk aliran buffer ini.

CanRead

Mendapatkan nilai yang menunjukkan apakah aliran saat ini mendukung pembacaan.

CanSeek

Mendapatkan nilai yang menunjukkan apakah aliran saat ini mendukung pencarian.

CanTimeout

Mendapatkan nilai yang menentukan apakah aliran saat ini dapat kehabisan waktu.

(Diperoleh dari Stream)
CanWrite

Mendapatkan nilai yang menunjukkan apakah aliran saat ini mendukung penulisan.

Length

Mendapatkan panjang aliran dalam byte.

Position

Mendapatkan posisi dalam aliran saat ini.

ReadTimeout

Mendapatkan atau menetapkan nilai, dalam milidetik, yang menentukan berapa lama aliran akan mencoba membaca sebelum waktu habis.

(Diperoleh dari Stream)
UnderlyingStream

Mendapatkan instans Stream yang mendasar untuk aliran buffer ini.

WriteTimeout

Mendapatkan atau menetapkan nilai, dalam milidetik, yang menentukan berapa lama aliran akan mencoba menulis sebelum waktu habis.

(Diperoleh dari Stream)

Metode

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

Memulai operasi baca asinkron. (Pertimbangkan untuk menggunakan ReadAsync(Byte[], Int32, Int32, CancellationToken) sebagai gantinya.)

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

Memulai operasi baca asinkron. (Pertimbangkan untuk menggunakan ReadAsync(Byte[], Int32, Int32) sebagai gantinya.)

(Diperoleh dari Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Memulai operasi penulisan asinkron. (Pertimbangkan untuk menggunakan WriteAsync(Byte[], Int32, Int32, CancellationToken) sebagai gantinya.)

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

Memulai operasi penulisan asinkron. (Pertimbangkan untuk menggunakan WriteAsync(Byte[], Int32, Int32) sebagai gantinya.)

(Diperoleh dari Stream)
Close()

Menutup aliran dan merilis sumber daya apa pun (terutama sumber daya sistem seperti soket dan handel file) yang terkait dengan aliran buffer saat ini.

Close()

Menutup aliran saat ini dan merilis sumber daya apa pun (seperti soket dan handel file) yang terkait dengan aliran saat ini. Alih-alih memanggil metode ini, pastikan aliran dibuang dengan benar.

(Diperoleh dari Stream)
CopyTo(Stream)

Membaca byte dari aliran saat ini dan menulisnya ke aliran lain. Kedua posisi aliran dimajukan dengan jumlah byte yang disalin.

(Diperoleh dari Stream)
CopyTo(Stream, Int32)

Membaca byte dari aliran buffer saat ini dan menulisnya ke aliran lain.

CopyTo(Stream, Int32)

Membaca byte dari aliran saat ini dan menulisnya ke aliran lain, menggunakan ukuran buffer tertentu. Kedua posisi aliran dimajukan dengan jumlah byte yang disalin.

(Diperoleh dari Stream)
CopyToAsync(Stream)

Secara asinkron membaca byte dari aliran saat ini dan menulisnya ke aliran lain. Kedua posisi aliran dimajukan dengan jumlah byte yang disalin.

(Diperoleh dari Stream)
CopyToAsync(Stream, CancellationToken)

Secara asinkron membaca byte dari aliran saat ini dan menulisnya ke aliran lain, menggunakan token pembatalan tertentu. Kedua posisi aliran dimajukan dengan jumlah byte yang disalin.

(Diperoleh dari Stream)
CopyToAsync(Stream, Int32)

Secara asinkron membaca byte dari aliran saat ini dan menulisnya ke aliran lain, menggunakan ukuran buffer tertentu. Kedua posisi aliran dimajukan dengan jumlah byte yang disalin.

(Diperoleh dari Stream)
CopyToAsync(Stream, Int32, CancellationToken)

Secara asinkron membaca byte dari aliran buffer saat ini dan menulisnya ke aliran lain, menggunakan ukuran buffer dan token pembatalan yang ditentukan.

CopyToAsync(Stream, Int32, CancellationToken)

Secara asinkron membaca byte dari aliran saat ini dan menulisnya ke aliran lain, menggunakan ukuran buffer dan token pembatalan yang ditentukan. Kedua posisi aliran dimajukan dengan jumlah byte yang disalin.

(Diperoleh dari Stream)
CreateObjRef(Type)

Membuat objek yang berisi semua informasi relevan yang diperlukan untuk menghasilkan proksi yang digunakan untuk berkomunikasi dengan objek jarak jauh.

(Diperoleh dari MarshalByRefObject)
CreateWaitHandle()
Kedaluwarsa.
Kedaluwarsa.
Kedaluwarsa.

Mengalokasikan objek WaitHandle.

(Diperoleh dari Stream)
Dispose()

Merilis semua sumber daya yang digunakan oleh Stream.

(Diperoleh dari Stream)
Dispose(Boolean)

Merilis sumber daya yang tidak dikelola yang digunakan oleh Stream dan secara opsional merilis sumber daya terkelola.

(Diperoleh dari Stream)
DisposeAsync()

Secara asinkron merilis sumber daya yang tidak dikelola yang digunakan oleh aliran yang di-buffer.

DisposeAsync()

Secara asinkron merilis sumber daya yang tidak dikelola yang digunakan oleh Stream.

(Diperoleh dari Stream)
EndRead(IAsyncResult)

Menunggu operasi baca asinkron yang tertunda selesai. (Pertimbangkan untuk menggunakan ReadAsync(Byte[], Int32, Int32, CancellationToken) sebagai gantinya.)

EndRead(IAsyncResult)

Menunggu pembacaan asinkron yang tertunda selesai. (Pertimbangkan untuk menggunakan ReadAsync(Byte[], Int32, Int32) sebagai gantinya.)

(Diperoleh dari Stream)
EndWrite(IAsyncResult)

Mengakhiri operasi tulis asinkron dan memblokir hingga operasi I/O selesai. (Pertimbangkan untuk menggunakan WriteAsync(Byte[], Int32, Int32, CancellationToken) sebagai gantinya.)

EndWrite(IAsyncResult)

Mengakhiri operasi penulisan asinkron. (Pertimbangkan untuk menggunakan WriteAsync(Byte[], Int32, Int32) sebagai gantinya.)

(Diperoleh dari Stream)
Equals(Object)

Menentukan apakah objek yang ditentukan sama dengan objek saat ini.

(Diperoleh dari Object)
Flush()

Menghapus semua buffer untuk aliran ini dan menyebabkan data buffer ditulis ke perangkat yang mendasar.

FlushAsync()

Secara asinkron menghapus semua buffer untuk aliran ini dan menyebabkan data yang di-buffer ditulis ke perangkat yang mendasar.

(Diperoleh dari Stream)
FlushAsync(CancellationToken)

Secara asinkron menghapus semua buffer untuk aliran ini, menyebabkan data yang di-buffer ditulis ke perangkat yang mendasar, dan memantau permintaan pembatalan.

FlushAsync(CancellationToken)

Secara asinkron menghapus semua buffer untuk aliran ini, menyebabkan data yang di-buffer ditulis ke perangkat yang mendasar, dan memantau permintaan pembatalan.

(Diperoleh dari Stream)
GetHashCode()

Berfungsi sebagai fungsi hash default.

(Diperoleh dari Object)
GetLifetimeService()
Kedaluwarsa.

Mengambil objek layanan seumur hidup saat ini yang mengontrol kebijakan seumur hidup untuk instans ini.

(Diperoleh dari MarshalByRefObject)
GetType()

Mendapatkan Type instans saat ini.

(Diperoleh dari Object)
InitializeLifetimeService()
Kedaluwarsa.

Mendapatkan objek layanan seumur hidup untuk mengontrol kebijakan seumur hidup untuk instans ini.

(Diperoleh dari MarshalByRefObject)
MemberwiseClone()

Membuat salinan dangkal dari Objectsaat ini.

(Diperoleh dari Object)
MemberwiseClone(Boolean)

Membuat salinan dangkal objek MarshalByRefObject saat ini.

(Diperoleh dari MarshalByRefObject)
ObjectInvariant()
Kedaluwarsa.

Menyediakan dukungan untuk Contract.

(Diperoleh dari Stream)
Read(Byte[], Int32, Int32)

Menyalin byte dari aliran buffer saat ini ke array.

Read(Span<Byte>)

Menyalin byte dari aliran buffer saat ini ke rentang byte dan memajukan posisi dalam aliran yang di-buffer dengan jumlah byte yang dibaca.

Read(Span<Byte>)

Ketika ditimpa dalam kelas turunan, membaca urutan byte dari aliran saat ini dan memajukan posisi dalam aliran dengan jumlah byte yang dibaca.

(Diperoleh dari Stream)
ReadAsync(Byte[], Int32, Int32)

Secara asinkron membaca urutan byte dari aliran saat ini dan memajukan posisi dalam aliran dengan jumlah byte yang dibaca.

(Diperoleh dari Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Secara asinkron membaca urutan byte dari aliran saat ini, memajukan posisi dalam aliran dengan jumlah byte yang dibaca, dan memantau permintaan pembatalan.

ReadAsync(Byte[], Int32, Int32, CancellationToken)

Secara asinkron membaca urutan byte dari aliran saat ini, memajukan posisi dalam aliran dengan jumlah byte yang dibaca, dan memantau permintaan pembatalan.

(Diperoleh dari Stream)
ReadAsync(Memory<Byte>, CancellationToken)

Secara asinkron membaca urutan byte dari aliran buffer saat ini dan memajukan posisi dalam aliran yang di-buffer dengan jumlah byte yang dibaca.

ReadAsync(Memory<Byte>, CancellationToken)

Secara asinkron membaca urutan byte dari aliran saat ini, memajukan posisi dalam aliran dengan jumlah byte yang dibaca, dan memantau permintaan pembatalan.

(Diperoleh dari Stream)
ReadAtLeast(Span<Byte>, Int32, Boolean)

Membaca setidaknya jumlah minimum byte dari aliran saat ini dan memajukan posisi dalam aliran dengan jumlah byte yang dibaca.

(Diperoleh dari Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)

Secara asinkron membaca setidaknya jumlah minimum byte dari aliran saat ini, memajukan posisi dalam aliran dengan jumlah byte yang dibaca, dan memantau permintaan pembatalan.

(Diperoleh dari Stream)
ReadByte()

Membaca byte dari aliran yang mendasar dan mengembalikan byte yang ditransmisikan ke int, atau mengembalikan -1 jika membaca dari akhir aliran.

ReadExactly(Byte[], Int32, Int32)

Membaca count jumlah byte dari aliran saat ini dan memajukan posisi dalam aliran.

(Diperoleh dari Stream)
ReadExactly(Span<Byte>)

Membaca byte dari aliran saat ini dan memajukan posisi dalam aliran hingga buffer terisi.

(Diperoleh dari Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)

Membaca secara asinkron count jumlah byte dari aliran saat ini, memajukan posisi dalam aliran, dan memantau permintaan pembatalan.

(Diperoleh dari Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)

Membaca byte secara asinkron dari aliran saat ini, memajukan posisi dalam aliran hingga buffer terisi, dan memantau permintaan pembatalan.

(Diperoleh dari Stream)
Seek(Int64, SeekOrigin)

Mengatur posisi dalam aliran buffer saat ini.

SetLength(Int64)

Mengatur panjang aliran yang di-buffer.

ToString()

Mengembalikan string yang mewakili objek saat ini.

(Diperoleh dari Object)
Write(Byte[], Int32, Int32)

Menyalin byte ke aliran yang di-buffer dan memajukan posisi saat ini dalam aliran yang di-buffer dengan jumlah byte yang ditulis.

Write(ReadOnlySpan<Byte>)

Menulis urutan byte ke aliran buffer saat ini dan memajukan posisi saat ini dalam aliran yang di-buffer ini dengan jumlah byte yang ditulis.

Write(ReadOnlySpan<Byte>)

Ketika ditimpa dalam kelas turunan, menulis urutan byte ke aliran saat ini dan memajukan posisi saat ini dalam aliran ini dengan jumlah byte yang ditulis.

(Diperoleh dari Stream)
WriteAsync(Byte[], Int32, Int32)

Secara asinkron menulis urutan byte ke aliran saat ini dan memajukan posisi saat ini dalam aliran ini dengan jumlah byte yang ditulis.

(Diperoleh dari Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Secara asinkron menulis urutan byte ke aliran saat ini, memajukan posisi saat ini dalam aliran ini dengan jumlah byte yang ditulis, dan memantau permintaan pembatalan.

WriteAsync(Byte[], Int32, Int32, CancellationToken)

Secara asinkron menulis urutan byte ke aliran saat ini, memajukan posisi saat ini dalam aliran ini dengan jumlah byte yang ditulis, dan memantau permintaan pembatalan.

(Diperoleh dari Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Secara asinkron menulis urutan byte ke aliran buffer saat ini, memajukan posisi saat ini dalam aliran yang di-buffer ini dengan jumlah byte yang ditulis, dan memantau permintaan pembatalan.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Secara asinkron menulis urutan byte ke aliran saat ini, memajukan posisi saat ini dalam aliran ini dengan jumlah byte yang ditulis, dan memantau permintaan pembatalan.

(Diperoleh dari Stream)
WriteByte(Byte)

Menulis byte ke posisi saat ini di aliran yang di-buffer.

Implementasi Antarmuka Eksplisit

IDisposable.Dispose()

Merilis semua sumber daya yang digunakan oleh Stream.

(Diperoleh dari Stream)

Metode Ekstensi

CopyToAsync(Stream, PipeWriter, CancellationToken)

Secara asinkron membaca byte dari Stream dan menulisnya ke PipeWriteryang ditentukan , menggunakan token pembatalan.

ConfigureAwait(IAsyncDisposable, Boolean)

Mengonfigurasi bagaimana menunggu tugas yang dikembalikan dari asinkron sekali pakai akan dilakukan.

Berlaku untuk

Lihat juga