BufferedStream クラス

[アーティクル]
03/28/2008

他のストリームに対する読み取り操作および書き込み操作にバッファリング層を追加します。このクラスは継承できません。

この型のすべてのメンバの一覧については、BufferedStream メンバを参照してください。

System.Object
   System.MarshalByRefObject
      System.IO.Stream
         System.IO.BufferedStream

NotInheritable Public Class BufferedStream
   Inherits Stream
[C#]
public sealed class BufferedStream : Stream
[C++]
public __gc __sealed class BufferedStream : public Stream
[JScript]
public class BufferedStream extends Stream

スレッドセーフ

この型の public static (Visual Basicでは Shared) のすべてのメンバは、マルチスレッド操作で安全に使用できます。インスタンスのメンバの場合は、スレッドセーフであるとは限りません。

解説

ファイルの作成およびテキストのファイルへの書き込みの例については、「ファイルへのテキストの書き込み」を参照してください。ファイルからのテキストの読み取りの例については、「ファイルからのテキストの読み取り」を参照してください。バイナリファイルからの読み取りおよびバイナリファイルへの書き込みの例については、「新しく作成したデータファイルの読み取りと書き込み」を参照してください。

バッファは、データをキャッシュするために使用するメモリ内のバイトのブロックです。これによって、オペレーティングシステムの呼び出しの回数が減少します。このように、バッファは読み取りと書き込みのパフォーマンスを向上させます。バッファは読み取りまたは書き込みのいずれかのために使用できますが、同時に両方のためには使用できません。 BufferedStream の Read メソッドと Write メソッドは、自動的にバッファを維持します。

BufferedStream は、特定の種類のストリームで作成できます。これにより基になるデータソースまたはリポジトリに対して、バイトの読み取りと書き込みが可能になります。他のデータ型の読み取りと書き込みには、 BinaryReader と BinaryWriter を使用します。 BufferedStream は、バッファが不要なときに、バッファによって入出力の速度が低下しないように設計されています。常に内部バッファサイズより大きいサイズの読み取りと書き込みを行う場合、 BufferedStream は、内部バッファさえも割り当てないことがあります。 BufferedStream は共有バッファにも読み取りと書き込みを格納します。ほとんどの場合、常に一連の読み取りまたは書き込みの操作を実行し、めったにこの 2 つの操作が切り替わらないことを前提にしています。

使用例

[Visual Basic, C#, C++] 次に示すのは、特定の I/O 操作のパフォーマンスを向上させるために、 BufferedStream クラスを NetworkStream クラス上で使用するコード例です。この例では、クライアントを起動する前にリモートコンピュータのサーバーを起動する必要があります。また、クライアントを起動するときには、コマンドライン引数としてリモートコンピュータ名を指定します。 dataArraySize 定数と streamBufferSize 定数にさまざまな値を使用することで、パフォーマンスへの影響を確認できます。

 
' Compile using /r:System.dll.
Imports Microsoft.VisualBasic
Imports System
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
        While bytesReceived < numberOfLoops * receivedData.Length
            bytesReceived += bufStream.Read( _
                receivedData, 0, receivedData.Length)
        End While
        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

[C#] 
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 execution exits the using statement, netStream
            // is disposed, which in turn shuts down the connection 
            // and closes clientSocket.
            Console.WriteLine("\nShutting down the connection.");
        }
    }

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

[C++] 
#using <mscorlib.dll>
#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 __gc class Client 
{
    static const int dataArraySize =   100;
    static const int numberOfLoops = 10000;

    Client() {}

public:
    static void ReceiveData(Stream* netStream, Stream* bufStream)
    {
        DateTime startTime;
        Double networkTime, bufferedTime = 0;
        int bytesReceived = 0;
        Byte receivedData __gc[] = new Byte __gc[dataArraySize];

        // Receive data using the NetworkStream.
        Console::WriteLine(S"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(S"{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(S"{0} bytes received in {1} seconds.\n",
            bytesReceived.ToString(), 
            bufferedTime.ToString("F1"));

        // Print the ratio of read times.
        Console::WriteLine(S"Receiving data using the buffered "
            S"network stream was {0} {1} than using the network "
            S"stream alone.",
            (networkTime/bufferedTime).ToString("P0"),
            bufferedTime < networkTime ? S"faster" : S"slower");
    }

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

        // Create random data to send to the server.
        Byte dataToSend __gc[] = new Byte __gc[dataArraySize];
        (new Random())->NextBytes(dataToSend);

        // Send the data using the NetworkStream.
        Console::WriteLine(S"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(S"{0} bytes sent in {1} seconds.\n",
            (numberOfLoops * dataToSend->Length).ToString(), 
            networkTime.ToString("F1"));

        // Send the data using the BufferedStream.
        Console::WriteLine(S"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(S"{0} bytes sent in {1} seconds.\n",
            (numberOfLoops * dataToSend->Length).ToString(), 
            bufferedTime.ToString("F1"));

        // Print the ratio of write times.
        Console::WriteLine(S"Sending data using the buffered "
            S"network stream was {0} {1} than using the network "
            S"stream alone.\n",
            (networkTime/bufferedTime).ToString("P0"),
            bufferedTime < networkTime ? S"faster" : S"slower");
    }
};

void main(int argc, char* argv[]) 
{
    // Check that an argument was specified when the 
    // program was invoked.
    if(argc == 1)
    {
        Console::WriteLine(S"Error: The name of the host computer"
            S" must be specified when the program is invoked.");
        return;
    }

    String* remoteName = argv[1];

    // 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.
    NetworkStream* netStream = new NetworkStream(clientSocket, true);
    BufferedStream* bufStream = 
        new BufferedStream(netStream, streamBufferSize);

    try
    {
        // Check whether the underlying stream supports seeking.
        Console::WriteLine(S"NetworkStream {0} seeking.\n",
            bufStream->CanSeek ? S"supports" : S"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(S"\nShutting down connection.");
        bufStream->Close();
    }
}

[Visual Basic] 
' Compile using /r:System.dll.
Imports Microsoft.VisualBasic
Imports System
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

[C#] 
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();
        }
    }
}

[C++] 
#using <mscorlib.dll>
#using <system.dll>
using namespace System;
using namespace System::Net;
using namespace System::Net::Sockets;

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.
    Socket* listenSocket = 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(S"Server is connected.\n");
    }
    __finally
    {
        listenSocket->Close();
    }

    try
    {
        // Send data to the client.
        Console::Write(S"Sending data ... ");
        int bytesSent = serverSocket->Send(
            dataToSend, 0, dataToSend->Length, SocketFlags::None);
        Console::WriteLine(S"{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(S"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(S"{0}: {1}\n", 
                    e->GetType()->Name, e->Message);
            }
        }
        __finally
        {
            Console::WriteLine(S"{0} bytes received.\n",
                totalReceived.ToString());
        }
    }
    __finally
    {
        serverSocket->Shutdown(SocketShutdown::Both);
        Console::WriteLine(S"Connection shut down.");
        serverSocket->Close();
    }
}

[JScript] JScript のサンプルはありません。Visual Basic、C#、および C++ のサンプルを表示するには、このページの左上隅にある言語のフィルタボタンをクリックします。

必要条件

名前空間: System.IO

プラットフォーム: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 ファミリ

アセンブリ: Mscorlib (Mscorlib.dll 内)

参照

BufferedStream クラス

スレッドセーフ

解説

使用例

必要条件

参照

その他のリソース