이 설명서는 보관되지만 유지 되지 않습니다.

BufferedStream 클래스

다른 스트림에서 읽기와 쓰기 작업에 버퍼링 계층을 추가합니다. 이 클래스는 상속될 수 없습니다.

네임스페이스: System.IO
어셈블리: mscorlib(mscorlib.dll)

[ComVisibleAttribute(true)] 
public sealed class BufferedStream : Stream
/** @attribute ComVisibleAttribute(true) */ 
public final class BufferedStream extends Stream
ComVisibleAttribute(true) 
public final class BufferedStream extends Stream

파일을 만들고 파일에 텍스트를 쓰는 방법에 대한 예제를 보려면 방법: 파일에 텍스트 쓰기를 참조하십시오. 파일에서 텍스트를 읽는 방법에 대한 예제를 보려면 방법: 파일의 텍스트 읽기를 참조하십시오. 이진 파일을 읽거나 쓰는 방법에 대한 예제를 보려면 방법: 새로 만든 데이터 파일 읽기 및 쓰기를 참조하십시오.

버퍼는 메모리의 바이트 블록으로서 데이터를 캐시하여 운영 체제에 대한 호출 수를 줄이는 데 사용됩니다. 버퍼를 사용하면 읽기 및 쓰기 성능이 향상됩니다. 읽기 또는 쓰기에 버퍼를 사용할 수 있지만 둘 모두에 동시에 사용할 수는 없습니다. BufferedStreamReadWrite 메서드는 버퍼를 자동으로 유지 관리합니다.

BufferedStream은 특정 형식의 스트림으로 구성할 수 있습니다. 이 클래스에서는 내부 데이터 소스 또는 리포지토리에 대한 바이트 읽기 및 쓰기를 구현합니다. 다른 데이터 형식을 읽고 쓰려면 BinaryReaderBinaryWriter를 사용합니다. BufferedStream은 버퍼가 필요하지 않을 때 버퍼로 인해 입/출력 속도가 저하되지 않도록 합니다. 항상 내부 버퍼 크기보다 큰 데이터를 읽고 쓰는 경우에는 BufferedStream이 내부 버퍼를 할당하지 못할 수도 있습니다. 또한 BufferedStream은 공유 버퍼를 사용하여 읽기와 쓰기를 버퍼링합니다. 대부분의 경우 일련의 읽기 또는 쓰기를 수행하지만 둘 사이를 번갈아 수행하는 경우는 거의 없는 것으로 가정합니다.

다음 코드 예제에서는 NetworkStream 클래스 위에서 BufferedStream 클래스를 사용하여 특정 I/O 작업의 성능을 향상시키는 방법을 보여 줍니다. 클라이언트를 시작하기 전에 원격 컴퓨터에서 서버를 시작합니다. 클라이언트를 시작할 때는 원격 컴퓨터 이름을 명령줄 인수로 지정합니다. 성능에 미친 효과를 확인하기 위해 dataArraySizestreamBufferSize 상수를 다양하게 설정합니다.

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");
    }
}

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

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

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에서 지원
표시: