BufferedStreamとは？ わかりやすく解説

.NET Framework クラス ライブラリ リファレンス
索引トップ 用語の索引 ランキング
日本マイクロソフト株式会社日本マイクロソフト株式会社

BufferedStream クラス

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

名前空間: System.IO
アセンブリ: mscorlib (mscorlib.dll 内)
構文構文

Visual Basic (宣言)
<ComVisibleAttribute(True)> _
Public NotInheritable Class
 BufferedStream
    Inherits Stream
Visual Basic (使用法)
Dim instance As BufferedStream
C#
[ComVisibleAttribute(true)] 
public sealed class BufferedStream : Stream
C++
[ComVisibleAttribute(true)] 
public ref class BufferedStream sealed : public
 Stream
J#
/** @attribute ComVisibleAttribute(true) */ 
public final class BufferedStream extends Stream
JScript
ComVisibleAttribute(true) 
public final class BufferedStream extends
 Stream
解説解説

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

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

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

使用例使用例

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

Visual Basic
' 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 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;
        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 <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();
      
   }

}
J#
import System.*;
import System.IO.*;
import System.Globalization.*;
import System.Net.*;
import System.Net.Sockets.*;

public class Client
{
    private static int dataArraySize
 = 100;
    private static int streamBufferSize
 = 1000;
    private static int numberOfLoops
 = 10000;

    public 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).get_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.

        Stream netStream = new NetworkStream(clientSocket, true);
        Stream bufStream = new BufferedStream(netStream, streamBufferSize);
        try {
            try {
                // Check whether the underlying stream supports seeking.
                Console.WriteLine("NetworkStream {0} seeking.\n",
                    (bufStream.get_CanSeek())? "supports" : "does
 not support");
                // Send and receive data.
                if ( bufStream.get_CanWrite()  ) {
                    SendData(netStream, bufStream);
                }
                if ( bufStream.get_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.");
            }
            finally {
                netStream.Dispose();
            }
        }
        finally {
            bufStream.Dispose();
        }         
    } //main   
   
    static void SendData(Stream netStream,
 Stream bufStream) 
    {
        DateTime startTime;
        double networkTime,bufferedTime;

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

        // Send the data using the NetworkStream.
        Console.WriteLine("Sending data using NetworkStream.");
        startTime = DateTime.get_Now();
        for(int i=0;i < numberOfLoops;i++)
 {
            netStream.Write(dataToSend, 0, dataToSend.length);
        }        
        networkTime =
            ((DateTime.get_Now()).Subtract(startTime)).get_TotalSeconds();
        Console.WriteLine("{0} bytes sent in {1} seconds.\n"
,
            System.Convert.ToString(numberOfLoops * dataToSend.length),
            ((System.Double) networkTime).ToString("F1"));

        // Send the data using the BufferedStream.
        Console.WriteLine("Sending data using BufferedStream.");
        startTime = DateTime.get_Now();
        for(int i=0;i < numberOfLoops;i++)
 {
            bufStream.Write(dataToSend, 0, dataToSend.length);
        }        
        bufStream.Flush();
        bufferedTime = 
            ((DateTime.get_Now()).Subtract(startTime)).get_TotalSeconds();
        Console.WriteLine("{0} bytes sent in {1} seconds.\n"
,
            System.Convert.ToString (numberOfLoops * dataToSend.length),
            ((System.Double)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",
            ((System.Double)(networkTime / bufferedTime)).ToString("P0")
,
            (bufferedTime < networkTime) ? "faster" : "slower");
    } //SendData
   
    static void ReceiveData(Stream netStream,
 Stream bufStream) 
    {
        DateTime startTime;
        double bufferedTime = 0;
        double networkTime;
        int bytesReceived = 0;
        ubyte receivedData[] = new ubyte[dataArraySize];

        // Receive data using the NetworkStream.
        Console.WriteLine("Receiving data using NetworkStream.");
        startTime = DateTime.get_Now();
        while((bytesReceived < numberOfLoops * receivedData.length))
 {
            bytesReceived += netStream.Read(receivedData,0,receivedData.length);
        }
        networkTime = 
            ((DateTime.get_Now()).Subtract(startTime)).get_TotalSeconds();
        Console.WriteLine("{0} bytes received in {1} seconds.\n"
,
            (new Integer(bytesReceived)).ToString(),
            ((System.Double)networkTime).ToString("F1"));

        // Receive data using the BufferedStream.
        Console.WriteLine("Receiving data using BufferedStream.");
        bytesReceived = 0;
        startTime = DateTime.get_Now();
        while((bytesReceived < numberOfLoops * receivedData.length))
 {
            bytesReceived += bufStream.Read(receivedData,0,receivedData.length);
        }
        bufferedTime =
            ((DateTime.get_Now()).Subtract(startTime)).get_TotalSeconds();
        Console.WriteLine("{0} bytes received in {1} seconds.\n"
,
            (new Integer(bytesReceived)).ToString(),
            ((System.Double) 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.",
            ((System.Double)(networkTime / bufferedTime)).ToString("P0")
,
            (bufferedTime < networkTime) ? "faster" : "slower");
    } //ReceiveData
} //Client
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 <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();
   }

}
継承階層継承階層
System.Object
   System.MarshalByRefObject
     System.IO.Stream
      System.IO.BufferedStream
スレッド セーフスレッド セーフ
この型の public static (Visual Basic では Shared) メンバはすべて、スレッド セーフです。インスタンス メンバの場合は、スレッド セーフであるとは限りません。
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0、1.1、1.0
参照参照
関連項目
BufferedStream メンバ
System.IO 名前空間
FileStream
MemoryStream
Stream
その他の技術情報
ファイルおよびストリーム入出力
方法 : ファイルからテキストを読み取る
方法 : ファイルにテキストを書き込む

BufferedStream コンストラクタ (Stream, Int32)

BufferedStream クラスの新しいインスタンスを、指定したバッファ サイズを使用して初期化します。

名前空間: System.IO
アセンブリ: mscorlib (mscorlib.dll 内)
構文構文

Visual Basic (宣言)
Public Sub New ( _
    stream As Stream, _
    bufferSize As Integer _
)
Visual Basic (使用法)
Dim stream As Stream
Dim bufferSize As Integer

Dim instance As New BufferedStream(stream,
 bufferSize)
C#
public BufferedStream (
    Stream stream,
    int bufferSize
)
C++
public:
BufferedStream (
    Stream^ stream, 
    int bufferSize
)
J#
public BufferedStream (
    Stream stream, 
    int bufferSize
)
JScript
public function BufferedStream (
    stream : Stream, 
    bufferSize : int
)

パラメータ

stream

現在のストリーム。

bufferSize

バイト単位のバッファ サイズ。

例外例外
例外の種類条件

ArgumentNullException

stream が null 参照 (Visual Basic では Nothing) です。

ArgumentOutOfRangeException

bufferSize が負の値です。

解説解説

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

共有読み取り/書き込みバッファは、最初に BufferedStream オブジェクトがこのコンストラクタで初期化されたときに割り当てられます。すべての読み取りと書き込みが bufferSize 以上の場合、共有バッファは使用されません。

使用例使用例

このコード例は、BufferedStream クラスのトピックで取り上げているコード例の一部分です。

Visual Basic
' 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)
C#
// 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))
C++
// 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 );
J#
// 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.

Stream netStream = new NetworkStream(clientSocket, true);
Stream bufStream = new BufferedStream(netStream, streamBufferSize);
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0、1.1、1.0
参照参照
関連項目
BufferedStream クラス
BufferedStream メンバ
System.IO 名前空間
その他の技術情報
ファイルおよびストリーム入出力
方法 : ファイルからテキストを読み取る
方法 : ファイルにテキストを書き込む

BufferedStream コンストラクタ (Stream)

BufferedStream クラスの新しいインスタンスを、4,096 バイトの既定のバッファ サイズを使用して初期化します。

名前空間: System.IO
アセンブリ: mscorlib (mscorlib.dll 内)
構文構文

Visual Basic (宣言)
Public Sub New ( _
    stream As Stream _
)
Visual Basic (使用法)
Dim stream As Stream

Dim instance As New BufferedStream(stream)
C#
public BufferedStream (
    Stream stream
)
C++
public:
BufferedStream (
    Stream^ stream
)
J#
public BufferedStream (
    Stream stream
)
JScript
public function BufferedStream (
    stream : Stream
)

パラメータ

stream

現在のストリーム。

例外例外
例外の種類条件

ArgumentNullException

stream が null 参照 (Visual Basic では Nothing) です。

解説解説

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

共有読み取り/書き込みバッファは、最初に BufferedStream オブジェクトがこのコンストラクタで初期化されたときに割り当てられます。すべての読み取りと書き込みが bufferSize 以上の場合、共有バッファは使用されません。

プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0、1.1、1.0
参照参照
関連項目
BufferedStream クラス
BufferedStream メンバ
System.IO 名前空間
その他の技術情報
ファイルおよびストリーム入出力
方法 : ファイルからテキストを読み取る
方法 : ファイルにテキストを書き込む

BufferedStream コンストラクタ

BufferedStream クラスの新しいインスタンスを初期化します。
オーバーロードの一覧オーバーロードの一覧

名前 説明
BufferedStream (Stream) BufferedStream クラスの新しいインスタンスを、4,096 バイトの既定のバッファ サイズを使用して初期化します。
BufferedStream (Stream, Int32) BufferedStream クラスの新しいインスタンスを、指定したバッファ サイズを使用して初期化します。
参照参照

関連項目

BufferedStream クラス
BufferedStream メンバ
System.IO 名前空間

その他の技術情報

ファイルおよびストリーム入出力
方法 : ファイルからテキストを読み取る
方法 : ファイルにテキストを書き込む

BufferedStream プロパティ


パブリック プロパティパブリック プロパティ

  名前 説明
パブリック プロパティ CanRead オーバーライドされます。 現在のストリームが読み取りをサポートしているかどうかを示す値を取得します。
パブリック プロパティ CanSeek オーバーライドされます。 現在のストリームがシークをサポートしているかどうかを示す値を取得します。
パブリック プロパティ CanTimeout  現在のストリームがタイムアウトできるかどうかを決定する値を取得します。 ( Stream から継承されます。)
パブリック プロパティ CanWrite オーバーライドされます。 現在のストリームが書き込みをサポートしているかどうかを示す値を取得します。
パブリック プロパティ Length オーバーライドされます。 バイト単位のストリーム長を取得します。
パブリック プロパティ Position オーバーライドされます。 現在のストリーム内の位置を取得します。
パブリック プロパティ ReadTimeout  ストリームがタイムアウト前に読み取りを試行する期間を決定する値を取得または設定します。 ( Stream から継承されます。)
パブリック プロパティ WriteTimeout  ストリームがタイムアウト前に書き込みを試行する期間を決定する値を取得または設定します。 ( Stream から継承されます。)
参照参照

関連項目

BufferedStream クラス
System.IO 名前空間
FileStream
MemoryStream
Stream

その他の技術情報

ファイルおよびストリーム入出力
方法 : ファイルからテキストを読み取る
方法 : ファイルにテキストを書き込む

BufferedStream メソッド


パブリック メソッドパブリック メソッド

  名前 説明
パブリック メソッド BeginRead  非同期の読み込み動作を開始します。 ( Stream から継承されます。)
パブリック メソッド BeginWrite  非同期の書き込み操作を開始します。 ( Stream から継承されます。)
パブリック メソッド Close  現在のストリームを閉じ、現在のストリームに関連付けられているすべてのリソース (ソケット、ファイル ハンドルなど) を解放します。 ( Stream から継承されます。)
パブリック メソッド CreateObjRef  リモート オブジェクトとの通信に使用するプロキシの生成に必要な情報をすべて格納しているオブジェクトを作成します。 ( MarshalByRefObject から継承されます。)
パブリック メソッド Dispose  Stream によって使用されているすべてのリソースを解放します。 ( Stream から継承されます。)
パブリック メソッド EndRead  保留中の非同期読み取りが完了するまで待機します。 ( Stream から継承されます。)
パブリック メソッド EndWrite  非同期書き込み操作を終了します。 ( Stream から継承されます。)
パブリック メソッド Equals  オーバーロードされます。 2 つの Object インスタンスが等しいかどうかを判断します。 ( Object から継承されます。)
パブリック メソッド Flush オーバーライドされます。 ストリームに対応するすべてのバッファをクリアし、バッファ内のデータを基になるデバイスに書き込みます。
パブリック メソッド GetHashCode  特定の型のハッシュ関数として機能します。GetHashCode は、ハッシュ アルゴリズムや、ハッシュ テーブルのようなデータ構造での使用に適しています。 ( Object から継承されます。)
パブリック メソッド GetLifetimeService  対象のインスタンスの有効期間ポリシーを制御する、現在の有効期間サービス オブジェクトを取得します。 ( MarshalByRefObject から継承されます。)
パブリック メソッド GetType  現在のインスタンスの Type を取得します。 ( Object から継承されます。)
パブリック メソッド InitializeLifetimeService  対象のインスタンスの有効期間ポリシーを制御する、有効期間サービス オブジェクトを取得します。 ( MarshalByRefObject から継承されます。)
パブリック メソッド Read オーバーライドされます。 現在のバッファ ストリームから配列にバイトをコピーします。
パブリック メソッド ReadByte オーバーライドされます。 基になるストリームからバイトを読み取り、int にキャストしたバイトを返すか、ストリームの末尾から読み取る場合は -1 を返します。
パブリック メソッド ReferenceEquals  指定した複数の Object インスタンスが同一かどうかを判断します。 ( Object から継承されます。)
パブリック メソッド Seek オーバーライドされます。 現在のバッファ ストリーム内の位置を設定します。
パブリック メソッド SetLength オーバーライドされます。 バッファ ストリーム長を設定します。
パブリック メソッド Synchronized  指定した Stream オブジェクトをラップするスレッド セーフな (同期された) ラッパーを作成します。 ( Stream から継承されます。)
パブリック メソッド ToString  現在の Object を表す String を返します。 ( Object から継承されます。)
パブリック メソッド Write オーバーライドされます。 バッファ ストリームにバイトをコピーし、書き込んだバイト数だけバッファ ストリームの現在位置を進めます。
パブリック メソッド WriteByte オーバーライドされます。 バッファ ストリームの現在位置にバイトを書き込みます。
参照参照

関連項目

BufferedStream クラス
System.IO 名前空間
FileStream
MemoryStream
Stream

その他の技術情報

ファイルおよびストリーム入出力
方法 : ファイルからテキストを読み取る
方法 : ファイルにテキストを書き込む

BufferedStream メンバ

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

BufferedStream データ型で公開されるメンバを以下の表に示します。


パブリック コンストラクタパブリック コンストラクタ
  名前 説明
パブリック メソッド BufferedStream オーバーロードされます。 BufferedStream クラスの新しいインスタンスを初期化します。
パブリック プロパティパブリック プロパティ
  名前 説明
パブリック プロパティ CanRead オーバーライドされます。 現在のストリームが読み取りをサポートしているかどうかを示す値を取得します。
パブリック プロパティ CanSeek オーバーライドされます。 現在のストリームがシークをサポートしているかどうかを示す値を取得します。
パブリック プロパティ CanTimeout  現在のストリームがタイムアウトできるかどうかを決定する値を取得します。(Stream から継承されます。)
パブリック プロパティ CanWrite オーバーライドされます。 現在のストリームが書き込みをサポートしているかどうかを示す値を取得します。
パブリック プロパティ Length オーバーライドされます。 バイト単位のストリーム長を取得します。
パブリック プロパティ Position オーバーライドされます。 現在のストリーム内の位置を取得します。
パブリック プロパティ ReadTimeout  ストリームがタイムアウト前に読み取りを試行する期間を決定する値を取得または設定します。 (Stream から継承されます。)
パブリック プロパティ WriteTimeout  ストリームがタイムアウト前に書き込みを試行する期間を決定する値を取得または設定します。 (Stream から継承されます。)
パブリック メソッドパブリック メソッド
  名前 説明
パブリック メソッド BeginRead  非同期の読み込み動作を開始します。 (Stream から継承されます。)
パブリック メソッド BeginWrite  非同期の書き込み操作を開始します。 (Stream から継承されます。)
パブリック メソッド Close  現在のストリームを閉じ、現在のストリームに関連付けられているすべてのリソース (ソケット、ファイル ハンドルなど) を解放します。 (Stream から継承されます。)
パブリック メソッド CreateObjRef  リモート オブジェクトとの通信に使用するプロキシの生成に必要な情報をすべて格納しているオブジェクトを作成します。 (MarshalByRefObject から継承されます。)
パブリック メソッド Dispose  Stream によって使用されているすべてのリソースを解放します。 (Stream から継承されます。)
パブリック メソッド EndRead  保留中の非同期読み取りが完了するまで待機します。 (Stream から継承されます。)
パブリック メソッド EndWrite  非同期書き込み操作を終了します。 (Stream から継承されます。)
パブリック メソッド Equals  オーバーロードされます。 2 つの Object インスタンスが等しいかどうかを判断します。 (Object から継承されます。)
パブリック メソッド Flush オーバーライドされます。 ストリームに対応するすべてのバッファをクリアし、バッファ内のデータを基になるデバイスに書き込みます。
パブリック メソッド GetHashCode  特定の型のハッシュ関数として機能します。GetHashCode は、ハッシュ アルゴリズムや、ハッシュ テーブルのようなデータ構造での使用に適しています。 (Object から継承されます。)
パブリック メソッド GetLifetimeService  対象のインスタンスの有効期間ポリシーを制御する、現在の有効期間サービス オブジェクトを取得します。 (MarshalByRefObject から継承されます。)
パブリック メソッド GetType  現在のインスタンスの Type を取得します。 (Object から継承されます。)
パブリック メソッド InitializeLifetimeService  対象のインスタンスの有効期間ポリシーを制御する、有効期間サービス オブジェクトを取得します。 (MarshalByRefObject から継承されます。)
パブリック メソッド Read オーバーライドされます。 現在のバッファ ストリームから配列にバイトをコピーします。
パブリック メソッド ReadByte オーバーライドされます。 基になるストリームからバイトを読み取り、int にキャストしたバイトを返すか、ストリームの末尾から読み取る場合は -1 を返します。
パブリック メソッド ReferenceEquals  指定した複数の Object インスタンスが同一かどうかを判断します。 (Object から継承されます。)
パブリック メソッド Seek オーバーライドされます。 現在のバッファ ストリーム内の位置を設定します。
パブリック メソッド SetLength オーバーライドされます。 バッファ ストリーム長を設定します。
パブリック メソッド Synchronized  指定した Stream オブジェクトをラップするスレッド セーフな (同期された) ラッパーを作成します。 (Stream から継承されます。)
パブリック メソッド ToString  現在の Object を表す String を返します。 (Object から継承されます。)
パブリック メソッド Write オーバーライドされます。 バッファ ストリームにバイトをコピーし、書き込んだバイト数だけバッファ ストリームの現在位置を進めます。
パブリック メソッド WriteByte オーバーライドされます。 バッファ ストリームの現在位置にバイトを書き込みます。
参照参照

関連項目

BufferedStream クラス
System.IO 名前空間
FileStream
MemoryStream
Stream

その他の技術情報

ファイルおよびストリーム入出力
方法 : ファイルからテキストを読み取る
方法 : ファイルにテキストを書き込む

急上昇のことば

こだわる
拘る
アゲサゲ
こだわり
最後から二番目の恋
英和和英テキスト翻訳>> Weblio翻訳
英語⇒日本語日本語⇒英語
  

辞書ショートカット

カテゴリ一覧

全て

＋ ビジネス

＋ 業界用語

＋ コンピュータ

＋ 電車

＋ 自動車・バイク

＋ 船

＋ 工学

＋ 建築・不動産

＋ 学問

＋ 文化

＋ 生活

＋ ヘルスケア

＋ 趣味

＋ スポーツ

＋ 生物

＋ 食品

＋ 人名

＋ 方言

＋ 辞書・百科事典

すべての辞書の索引

あいうえお
かきくけこ
さしすせそ
たちつてと
なにぬねの
はひふへほ
まみむめも
やゆよ
らりるれろ
わをん
がぎぐげご
ざじずぜぞ
だぢづでど
ばびぶべぼ
ぱぴぷぺぽ
ＡＢＣＤＥ
ＦＧＨＩＪ
ＫＬＭＮＯ
ＰＱＲＳＴ
ＵＶＷＸＹ
Ｚ
１２３４５
６７８９０
記号

Weblioのサービス

「BufferedStream」の関連用語

1
BufferedStream コンストラクタ
.NET Framework クラス ライブラリ リファレンス
100% |||||

2
System.IO.BufferedStream
ウィキペディア小見出し辞書
90% |||||

3
BufferedStream.Flush メソッド
.NET Framework クラス ライブラリ リファレンス
72% |||||

4
BufferedStream.Write メソッド
.NET Framework クラス ライブラリ リファレンス
56% |||||

5
Stream フィールド
.NET Framework クラス ライブラリ リファレンス
52% |||||

6
Stream プロパティ
.NET Framework クラス ライブラリ リファレンス
52% |||||

7
BufferedStream.Read メソッド
.NET Framework クラス ライブラリ リファレンス
38% |||||

8
BufferedStream クラス
.NET Framework クラス ライブラリ リファレンス
36% |||||

9
BufferedStream.Length プロパティ
.NET Framework クラス ライブラリ リファレンス
34% |||||

10
BufferedStream.WriteByte メソッド
.NET Framework クラス ライブラリ リファレンス
34% |||||

BufferedStreamのお隣キーワード

BufferedGraphicsContext.MaximumBuffer プロパティ

BufferedGraphicsManager クラス

BufferedGraphicsManager プロパティ

BufferedGraphicsManager メソッド

BufferedGraphicsManager メンバ

BufferedGraphicsManager.Current プロパティ

BufferedStream

BufferedStream クラス

BufferedStream コンストラクタ

BufferedStream プロパティ

BufferedStream メソッド

BufferedStream メンバ

BufferedStream.CanRead プロパティ

検索ランキング

   

 英語⇒日本語
日本語⇒英語		    


BufferedStreamのページの著作権
Weblio 辞書 情報提供元は 参加元一覧 にて確認できます。

   
日本マイクロソフト株式会社日本マイクロソフト株式会社
© 2025 Microsoft.All rights reserved.

©2025 GRAS Group, Inc.RSS